openai_101 0.2.0 → 1.0.0

data/gpt-context/theme-prompts.csv

@@ -0,0 +1,21 @@
+Theme,Prompt
+"Futuristic Cityscapes", "A bustling futuristic cityscape where AI and humans coexist seamlessly, with drones flying overhead and digital billboards displaying AI-generated art"
+"Digital Renaissance", "A digital recreation of a Renaissance scene, where figures interact with AI devices, blending classical beauty with modern technology"
+"AI in Nature", "A serene forest where trees and wildlife are monitored and cared for by gentle AI robots, highlighting a balance between technology and natural preservation"
+"Cybernetic Organisms", "A close-up of a flower with digital circuit patterns on its petals, symbolizing the fusion of organic life with AI enhancements"
+"Virtual Reality Worlds", "An individual wearing a VR headset, transported to a breathtaking AI-created fantasy world, showcasing the limitless possibilities of virtual reality"
+"AI as a Companion", "A friendly AI robot walking alongside a human in a park, offering guidance and companionship, symbolizing the supportive role of AI"
+"Abstract Data Visualizations", "An abstract representation of a neural network, with flowing streams of data and colorful nodes, visualizing the complexity and beauty of AI algorithms"
+"Steampunk AI", "A steampunk-inspired workshop with AI robots made of brass and gears, working alongside humans to invent new technologies"
+"Space Exploration", "A robotic AI explorer navigating the rugged terrain of an alien planet, with a distant galaxy shining brightly in the sky above"
+"Underwater Discoveries", "AI-powered submarines exploring coral reefs and ancient underwater ruins, illuminating the depths with advanced technology"
+"Mythical Integration", "A majestic phoenix with digital wings soaring above a futuristic city, blending mythology with advanced AI technology"
+"Digital Nomads", "A group of tech-savvy digital nomads in a remote, exotic location, using AI to work and communicate from anywhere in the world"
+"Retro-Futurism", "A scene set in a neon-lit arcade from the 1980s, where gamers are playing AI-developed video games that predict future events"
+"AI Guardians", "A powerful AI guardian overseeing the digital safety of a smart city, visualized as a holographic entity projecting from a city's central tower"
+"Dystopian vs Utopian AI", "A split scene showing one side as a dystopian world overwhelmed by AI surveillance and control, and the other as a utopian society where AI enhances quality of life"
+"Quantum Computing", "An ethereal quantum realm where qubits float in a space-like environment, representing the power and mystery of quantum computing in AI"
+"AI in Sports and Fitness", "An athletic training session where an AI coach provides personalized feedback and strategies to an athlete wearing smart wearables"
+"Education Through AI", "A futuristic classroom where holographic projections of AI tutors teach students from around the globe in an interactive learning environment"
+"AI in Art and Music", "An AI painting a masterpiece while another composes a symphony, showcasing the creative potential of AI in art and music"
+"AI as a Time Traveler", "An AI entity interacting with historical figures across different eras, from ancient civilizations to future societies, illustrating the timeless impact of AI"

data/lib/openai_101/config/openai.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'dotenv'
+# Dotenv.load(".env.#{ENV['APP_ENV']}") # Loads environment-specific dotenv file.
+Dotenv.load('.env')
+
+OpenAI.configure do |config|
+  tools_enabled = ENV.fetch('TOOLS_ENABLED', 'false')
+
+  if tools_enabled == 'true'
+    puts 'OpenAI Tools are enabled'
+    config.access_token = ENV.fetch('OPENAI_ACCESS_TOKEN')
+    config.organization_id = ENV.fetch('OPENAI_ORGANIZATION_ID', nil)
+  end
+end

data/lib/openai_101/tools/automate-images-chatgpt.js

@@ -0,0 +1,60 @@
+const { Command } = require('commander');
+const fs = require('fs');
+const robot = require("robotjs");
+
+const program = new Command();
+
+program
+  .option('-f, --file <filename>', 'The file to read prompts from', 'prompts.txt')
+  .option('-o, --completed-file <filename>', 'The file to write completed prompts to', 'completed.txt')
+  .option('-i, --interval <seconds>', 'The interval in seconds between prompts', 80)
+  .option('-m, --max-images <number>', 'The maximum number of images to process', 20);
+
+program.parse(process.argv);
+
+function read_prompts_from_file(file, maxImages) {
+  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+  return prompts.slice(0, maxImages);
+}
+
+function remove_prompt_from_file(file, prompt) {
+  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+  const index = prompts.indexOf(prompt);
+  if (index !== -1) {
+    prompts.splice(index, 1);
+    fs.writeFileSync(file, prompts.join('\n'));
+  }
+}
+
+function append_prompt_to_file(file, prompt) {
+  fs.appendFileSync(file, `${prompt}\n`);
+}
+
+function wait(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function send_prompt_to_chat(prompt) {
+  const formattedPrompt = `create image: ${prompt}`;
+  robot.typeString(formattedPrompt);
+  robot.keyTap('enter');
+}
+
+async function start() {
+  console.log('Starting Image Creation Automation');
+  console.log('Please open the ChatGPT interface where you intend to use this script.');
+  console.log('Automation will begin in 10 seconds.');
+  await wait(10000);
+
+  const prompts = read_prompts_from_file(program.opts().file, parseInt(program.opts().maxImages));
+  for (let prompt of prompts) {
+    console.log(`Sending prompt "${prompt}"...`);
+    await send_prompt_to_chat(prompt);
+    await wait(program.opts().interval * 1000);
+    remove_prompt_from_file(program.opts().file, prompt);
+    append_prompt_to_file(program.opts().completedFile, prompt);
+  }
+  console.log('Automation complete.');
+}
+
+start();

data/lib/openai_101/tools/automate-images-midjourney.js

@@ -0,0 +1,75 @@
+const { Command } = require('commander');
+const fs = require('fs');
+const robot = require("robotjs");
+
+const program = new Command();
+
+program
+  .option('-f, --file <filename>', 'The file to read prompts from', 'prompts.txt')
+  .option('-o, --completed-file <filename>', 'The file to write completed prompts to', 'completed.txt')
+  .option('-i, --interval <seconds>', 'The interval in seconds between prompts', 4)
+  .option('-p, --prompts-per-session <prompts>', 'The number of prompts to process in a session', 7)
+  .option('-w, --wait-between-sessions <seconds>', 'The number of seconds to wait between sessions', 180);
+
+program.parse(process.argv);
+
+function read_next_prompt_from_file(file) {
+  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+  return prompts.shift();
+}
+
+function remove_prompt_from_file(file, prompt) {
+  const lockfile = `${file}.lock`;
+  fs.writeFileSync(lockfile, '', { flag: 'wx' });
+  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
+  const index = prompts.indexOf(prompt);
+  prompts.splice(index, 1);
+  fs.writeFileSync(file, prompts.join('\n'));
+  fs.unlinkSync(lockfile);
+}
+
+function append_prompt_to_file(file, prompt) {
+  const lockfile = `${file}.lock`;
+  fs.writeFileSync(lockfile, '', { flag: 'wx' });
+  fs.appendFileSync(file, `${prompt}\n`);
+  fs.unlinkSync(lockfile);
+}
+
+function wait(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    // Wait
+  }
+}
+
+function send_prompt_to_discord(prompt) {
+  const formattedPrompt = `/imagine prompt: ${prompt}`;
+  robot.typeString(formattedPrompt);
+  robot.keyTap('enter');
+}
+
+function start() {
+  console.log('Starting MidJourney Automation');
+  console.log('Please open Discord and navigate to the MidJourney channel.');
+  console.log('Automation will begin in 10 seconds.');
+  wait(10 * 1000);
+
+  let index = 0;
+  let prompt = read_next_prompt_from_file(program.opts().file);
+  while (prompt) {
+    console.log(`Sending prompt "${prompt}"...`);
+    send_prompt_to_discord(prompt);
+    wait(program.opts().interval * 1000);
+    remove_prompt_from_file(program.opts().file, prompt);
+    append_prompt_to_file(program.opts().completedFile, prompt);
+    index++;
+    if (index % program.opts().promptsPerSession === 0) {
+      console.log(`Pausing for ${program.opts().waitBetweenSessions} seconds.`);
+      wait(program.opts().waitBetweenSessions * 1000);
+    }
+    prompt = read_next_prompt_from_file(program.opts().file);
+  }
+  console.log('Automation complete.');
+}
+
+start();

data/lib/openai_101/tools/bulk_image_bot/base_automator.js

@@ -0,0 +1,53 @@
+const fs = require('fs');
+const { promisify } = require('util');
+const robot = require("robotjs");
+
+const wait = promisify(setTimeout);
+
+class BaseAutomator {
+  constructor({ file, completedFile, interval = 5, maxImages = 20 }) {
+    this.file = file;
+    this.completedFile = completedFile;
+    this.interval = interval;
+    this.maxImages = maxImages;
+  }
+
+  async readPromptsFromFile() {
+    try {
+      const content = await fs.promises.readFile(this.file, 'utf-8');
+      return content.split('\n').filter(Boolean).slice(0, this.maxImages);
+    } catch (error) {
+      console.error('Error reading prompts from file:', error);
+      return [];
+    }
+  }
+
+  async appendToCompletedFile(prompt) {
+    try {
+      await fs.promises.appendFile(this.completedFile, `${prompt}\n`);
+    } catch (error) {
+      console.error('Error appending prompt to completed file:', error);
+    }
+  }
+
+  async removeFromInputFile(prompt) {
+    try {
+      let prompts = await this.readPromptsFromFile();
+      prompts = prompts.filter(line => line !== prompt);
+      await fs.promises.writeFile(this.file, prompts.join('\n'));
+    } catch (error) {
+      console.error('Error removing prompt from input file:', error);
+    }
+  }
+
+  async waitInterval() {
+    await wait(this.interval * 1000);
+  }
+
+  async sendKeystrokes(string) {
+    robot.typeString(string);
+    robot.keyTap('enter');
+  }
+}
+
+module.exports = BaseAutomator;

data/lib/openai_101/tools/bulk_image_bot/chatgpt_automator.js

@@ -0,0 +1,27 @@
+const BaseAutomator = require('./base_automator');
+
+class ChatGPTAutomator extends BaseAutomator {
+  constructor(options) {
+    super(options);
+  }
+
+  async sendPromptToChat(prompt) {
+    const formattedPrompt = `create image: ${prompt}`;
+    await this.sendKeystrokes(formattedPrompt);
+    console.log(`Sending prompt "${prompt}" to ChatGPT...`);
+  }
+
+  async start() {
+    console.log('Starting ChatGPT Image Creation Automation');
+    const prompts = await this.readPromptsFromFile();
+    for (const prompt of prompts) {
+      await this.sendPromptToChat(prompt);
+      await this.waitInterval();
+      await this.removeFromInputPromptFile(prompt);
+      await this.appendToCompletedPromptFile(prompt);
+    }
+    console.log('Automation complete.');
+  }
+}
+
+module.exports = ChatGPTAutomator;

data/lib/openai_101/tools/bulk_image_bot/midjourney_automator.js

@@ -0,0 +1,49 @@
+const BaseAutomator = require('./base_automator');
+const fs = require('fs');
+const robot = require("robotjs");
+
+class MidJourneyAutomator extends BaseAutomator {
+  constructor(options) {
+    super(options);
+  }
+
+  async sendPromptToDiscord(prompt) {
+    const formattedPrompt = this.formatPrompt(prompt);
+    this.sendKeystrokes(formattedPrompt);
+  }
+
+  formatPrompt(prompt) {
+    return `/imagine prompt: ${prompt}`;
+  }
+
+  sendKeystrokes(string) {
+    robot.typeString(string);
+    robot.keyTap('enter');
+  }
+
+  async start() {
+    console.log('Starting MidJourney Automation');
+    console.log('Please open Discord and navigate to the MidJourney channel.');
+    console.log('Automation will begin in 10 seconds.');
+    await this.wait(10 * 1000);
+
+    let index = 0;
+    let prompt = await this.readNextPromptFromFile();
+    while (prompt) {
+      console.log(`Sending prompt "${prompt}"...`);
+      await this.sendPromptToDiscord(prompt);
+      await this.wait(this.interval * 1000);
+      await this.removePromptFromFile(prompt);
+      await this.appendToCompletedFile(this.completedFile, prompt);
+      index++;
+      if (index % this.maxImages === 0) {
+        console.log(`Pausing for ${this.waitBetweenSessions} seconds.`);
+        await this.wait(this.waitBetweenSessions * 1000);
+      }
+      prompt = await this.readNextPromptFromFile();
+    }
+    console.log('Automation complete.');
+  }
+}
+
+module.exports = MidJourneyAutomator;

data/lib/openai_101/tools/clean_ruby_errors.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Openai101
+  module Tools
+    # Clean Ruby Errors
+    module ReportFormatter
+      def print_column_names(column_definitions)
+        headings = column_definitions.map { |_, col| col[:label].ljust(col[:width]) }.join(' | ')
+        separator_length = column_definitions.sum { |_, col| col[:width] } + ((column_definitions.keys.size - 1) * 3)
+
+        puts '-' * separator_length
+        puts headings
+        puts '-' * separator_length
+      end
+
+      def print_line(column_definitions, **column_key_values)
+        line = column_definitions.map do |key, col|
+          value = column_key_values[key] || ''
+          value.to_s.ljust(col[:width])
+        end.join(' | ')
+        puts line
+      end
+    end
+
+    # Convert EDL to YouTube description chapters
+    class CleanRubyErrors
+      include ReportFormatter
+
+      attr_reader :file
+      attr_reader :error
+      attr_reader :errors
+
+      def initialize(file)
+        @file = file
+        @errors = []
+      end
+
+      def parse
+        capture_code = []
+        capture_stack = []
+
+        lines.each do |line|
+          @section = detect_section(line)
+
+          case section
+          when :new_error
+            add_stack_to_error(error, capture_stack) if capture_stack.any? && error
+
+            @error = initialize_error(line)
+            errors << error
+
+          when :failure_error1
+            error[:error_technique] = '1'
+            capture_code = []
+            @section = :capture_failure_error
+          when :failure_error2
+            error[:error_technique] = '2'
+            capture_code = []
+            @section = :capture_failure_error
+          when :capture_failure_error
+            capture_code << line.rstrip
+          when :actual_error
+            error[:error_type] = line.strip
+            error[:code_section] = format_code(capture_code)
+            capture_stack = []
+            @section = :capture_stack
+          when :capture_stack
+            capture_stack << line.strip
+          end
+        end
+
+        add_stack_to_error(error, capture_stack) if capture_stack.any? && error
+      end
+
+      def print_errors(errors)
+        column_definitions = {
+          test_number: { label: '#', width: 5 },
+          test_technique: { label: 'Style', width: 7 },
+          error_at: { label: 'Error At', width: 70 },
+          error_by: { label: 'Error By', width: 80 },
+          error_type: { label: 'Error Type', width: 20 },
+          error_message: { label: 'Error Message', width: 180 }
+        }
+
+        print_column_names(column_definitions)
+
+        errors.each do |error|
+          print_line(column_definitions,
+                     test_number: error[:test_number],
+                     test_technique: error[:error_technique],
+                     error_at: "#{error[:error_at][:file]}:#{error[:error_at][:line]}",
+                     error_by: "#{error[:error_by][:file]}:#{error[:error_by][:line]}",
+                     error_type: error[:error_type],
+                     error_message: error[:error_message])
+        end
+
+        print_column_names(column_definitions)
+      end
+
+      def print_aggregated_error(errors)
+        aggregated_errors = aggregate_errors(errors)
+        # puts JSON.pretty_generate(aggregated_errors.first)
+
+        # puts '----------------------'
+        # puts aggregated_errors.first
+
+        column_definitions = {
+          error_type: { label: 'Error Type', width: 20 },
+          error_message: { label: 'Error Message', width: 180 },
+          error_at_file: { label: 'Error At File', width: 70 },
+          error_at_lines: { label: 'L#', width: 5 },
+          error_by_file: { label: 'Error By File', width: 80 },
+          error_by_lines: { label: 'Lines', width: 30 }
+        }
+
+        print_column_names(column_definitions)
+
+        aggregated_errors.each do |error|
+          print_line(column_definitions,
+                     error_type: error[:error_type],
+                     error_message: error[:error_message],
+                     error_at_file: error[:error_at_file],
+                     error_at_lines: error[:error_at_lines].join(', '),
+                     error_by_file: error[:error_by_file],
+                     error_by_lines: error[:error_by_lines].join(', '))
+        end
+
+        print_column_names(column_definitions)
+      end
+
+      #   # column_definitions = {
+      #   #   error_message: { label: "Error Message", width: 180 },
+      #   # }
+
+      #   # # Print the report
+      #   # puts "Error Message | Source File(Line Numbers) | Spec File(Line Numbers)"
+      #   # puts "-" * 100
+
+      #   # aggregated_errors.each do |(message, source_file, spec_file), lines|
+      #   #   source_lines = lines[:source_lines].uniq.sort.join(', ')
+      #   #   spec_lines = lines[:spec_lines].uniq.sort.join(', ')
+      #   #   puts "#{message} | #{source_file}(#{source_lines}) | #{spec_file}(#{spec_lines})"
+      #   # end
+      # end
+
+      private
+
+      def lines
+        @lines ||= File.readlines(file)
+      end
+
+      def detect_section(line)
+        return :new_error           if line.match?(/^\d+\)/)
+        return :failure_error2      if line.include?('Failure/Error: ') # Note the space
+        return :failure_error1      if line.include?('Failure/Error:')
+        return :actual_error        if line.include?('Error:')
+
+        section
+      end
+
+      def section
+        @section ||= :start
+      end
+
+      def initialize_error(line)
+        {
+          error_type: '',
+          error_technique: '',
+          test_number: extract_error_number(line),
+          code_section: [],
+          error_message: '',
+          error_messages: [],
+          stack: [],
+          error_at: { file: '', line: 0 },
+          error_by: { file: '', line: 0 }
+        }
+      end
+
+      def extract_error_number(line)
+        match = line.match(/^(\d+)\)/)
+        match ? match[1] : nil
+      end
+
+      def format_code(code_lines)
+        return 'Investigate!!!' if code_lines.empty?
+
+        first_line_spaces = code_lines.first[/\A */].size
+        code_lines.map { |line| line[first_line_spaces..] }.compact
+      end
+
+      def add_stack_to_error(error, stack_lines)
+        error_messages, stack_trace = split_strack_from_errors(stack_lines)
+
+        error[:error_message] = error_messages.join(' ')
+        error[:error_messages] = error_messages
+        error[:stack] = stack_trace
+
+        error[:error_at] = extract_error_location(stack_trace)
+        error[:error_by] = extract_test_location(stack_trace)
+      end
+
+      def split_strack_from_errors(stack_lines)
+        error_messages, stack_trace = stack_lines.partition { |line| !line.start_with?('#') }
+
+        clean_error_messages = error_messages.reject(&:empty?)
+        clean_stack_trace = stack_trace.map { |line| line.sub(/^#\s*/, '') }
+
+        [clean_error_messages, clean_stack_trace]
+      end
+
+      def extract_error_location(stack_trace)
+        return { file: '', line: 0 } if stack_trace.empty?
+
+        # Matches on file paths ending in .rb followed by a colon and a line number.
+        # It captures the file path and line number into named groups 'file' and 'line'.
+        # Example Match: "./app/models/user.rb:13" => file: "./app/models/user.rb", line: "13"
+        match = stack_trace.first.match(/(?<file>.*\.rb):(?<line>\d+)/)
+        match ? { file: match[:file], line: match[:line] } : { file: 'XXXXXX1', line: 0 }
+      end
+
+      def extract_test_location(stack_trace)
+        stack_trace.reverse_each do |trace_line|
+          # Searches for file paths that specifically end with _spec.rb (indicating a test file),
+          # followed by a colon and a line number. It captures the test file path and line number.
+          # Example Match: "./spec/models/user_spec.rb:26" => file: "./spec/models/user_spec.rb", line: "26"
+          if (match = trace_line.match(/(?<file>.*_spec\.rb):(?<line>\d+)/))
+            return { file: match[:file], line: match[:line] }
+          end
+        end
+        { file: 'XXXXXX2', line: 0 } # Return a default value if no test location is found
+      end
+
+      def aggregate_errors(errors)
+        # Initialize an empty hash for aggregations
+        aggregated_errors = {}
+
+        errors.each do |error|
+          # Create a unique key for each aggregation based on error_message, error_at[:file], and error_by[:file]
+          key = [
+            error[:error_message],
+            error[:error_at][:file],
+            error[:error_by][:file]
+          ].join('|')
+
+          # If the aggregation key doesn't exist, initialize it
+          aggregated_errors[key] ||= {
+            error_type: error[:error_type],
+            error_message: error[:error_message],
+            code_section: error[:code_section], # Assuming code_section is the same for aggregated errors
+            error_at: { file: error[:error_at][:file], lines: [] },
+            error_by: { file: error[:error_by][:file], lines: [] }
+          }
+
+          # Append unique error messages and line numbers for error_at and error_by
+          aggregated_errors[key][:error_at][:lines] |= [error[:error_at][:line]]
+          aggregated_errors[key][:error_by][:lines] |= [error[:error_by][:line]]
+        end
+
+        # Convert the aggregated_errors hash back into an array of values
+        aggregated_errors.values.map do |error|
+          {
+            error_type: error[:error_type],
+            error_message: error[:error_message],
+            code_section: error[:code_section].join("\n"),
+            error_at_file: error[:error_at][:file],
+            error_at_lines: error[:error_at][:lines],
+            error_by_file: error[:error_by][:file],
+            error_by_lines: error[:error_by][:lines]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/openai_101/tools/edl_to_chapters.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Openai101
+  module Tools
+    # Convert EDL to YouTube description chapters
+    class EdlToChapters
+      attr_reader :content
+
+      def initialize(content: nil, file: nil)
+        @content = content
+        @content = File.read(file) if file
+      end
+
+      def convert
+        # TITLE: a36
+        # FCM: NON-DROP FRAME
+
+        # 001  001      V     C        00:00:09:16 00:00:09:17 00:00:09:16 00:00:09:17
+        #  |C:ResolveColorBlue |M:Hey Code Voice Commands |D:1
+
+        # 002  001      V     C        00:00:53:13 00:00:53:14 00:00:53:13 00:00:53:14
+        #  |C:ResolveColorBlue |M:Keyboard Shortcuts |D:1
+
+        # 003  001      V     C        00:01:17:20 00:01:17:21 00:01:17:20 00:01:17:21
+        #  |C:ResolveColorBlue |M:Create code using voice |D:1
+
+        # 004  001      V     C        00:02:17:25 00:02:17:26 00:02:17:25 00:02:17:26
+        #  |C:ResolveColorBlue |M:Next steps |D:1
+
+        chapters = []
+        chapter = nil
+        content.each_line do |line|
+          line = line.strip
+
+          if line =~ /^\d{3}/
+            chapter = build_chapter(line)
+            chapters << chapter
+            next
+          end
+
+          chapter[:description] = line.match(/\|M:(.+?)\|/)[1].strip if chapter && line.match(/\|M:(.+?)\|/) && line.match(/\|M:(.+?)\|/)[1]
+        end
+        chapters.map { |item| "#{item[:time]} #{item[:description]}" }.join("\n")
+      end
+
+      def build_chapter(line)
+        time_code = line.split(/\s+/)[5] # Extract time code
+        hours, minutes, seconds, frames = time_code.split(':').map(&:to_i)
+        total_seconds = (hours * 3600) + (minutes * 60) + seconds + (frames / 30.0)
+        formatted_time = format('%<hours>02d:%<minutes>02d:%<seconds>02d', hours: total_seconds / 3600, minutes: (total_seconds / 60) % 60, seconds: total_seconds % 60)
+
+        { time: formatted_time }
+      end
+    end
+  end
+end

data/lib/openai_101/tools/file_content_gatherer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Openai101
+  module Tools
+    # Gather content from files in a directory, used by gpt_context_gatherer.rb
+    class FileContentGatherer
+      attr_reader :include_patterns, :exclude_patterns
+
+      def initialize(include_pattern: nil, include_patterns: [], exclude_patterns: [])
+        @include_patterns = Array(include_pattern) + include_patterns
+        @exclude_patterns = exclude_patterns
+      end
+
+      def build
+        concatenated_content = []
+
+        include_patterns.each do |pattern|
+          Dir.glob(pattern).each do |file_path|
+            next if excluded?(file_path) || File.directory?(file_path)
+
+            content = "# file: #{file_path}\n\n#{File.read(file_path)}"
+            concatenated_content << content
+          end
+        end
+
+        concatenated_content.join("\n\n")
+      end
+
+      private
+
+      def excluded?(file_path)
+        exclude_patterns.any? { |pattern| File.fnmatch(pattern, file_path) }
+      end
+    end
+  end
+end