klue-langcraft 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '07528e25c004b36664752d235737a9f6f521e231eb2b9e900884861e2fbeccad'
-  data.tar.gz: bd96ac7b1247f8f4fe123b4bb7923df50f1067120b1faa6e1121c6936fe400d1
+  metadata.gz: 991b394224dd15a2eccfe3ce1db7b6bca00304d8c6cf75ac8763a34beb6b9d06
+  data.tar.gz: 9a814b4cb28a1eefe7763c7705f652f754c567404748e326c60049e7d9f7f7c1
 SHA512:
-  metadata.gz: f270af8583b0ef01f5c290f0d69abe2de5534682169440381532fea9510c0b2b03f7c247c13dcde3fd13dc88b89fdadc3255af804138b6373513ea16a32b31d6
-  data.tar.gz: e23279553bc9f644ebe56ce796dd99cda278c10170142806e2a9ed59839a3a51a541de9b0b75082474e46f130cd6e3e5d037d2c5e9c475585280ba032d84a6d8
+  metadata.gz: e34c11144fefacb28af86e336e48f5bc905fb2a4db2ea75079689fcd21a1ecbc2f5ea8a6ffac8fbc16713a32323007279c3b208655c3864d29861848d84b38d2
+  data.tar.gz: 990a9b599923fc5a7117f0fafe0a20057f63798ebbef06a02de8b9debc3b900b6bc1797a9fcd472301b74d10944077077e25aa333fd001a81b88619fdecd668e

data/.rubocop.yml

@@ -40,8 +40,23 @@ Metrics/BlockLength:
     - shared_examples_for
     - transaction
 
+Metrics/AbcSize:
+  Exclude:
+    - bin/*
+
+
 Metrics/MethodLength:
   Max: 25
+  Exclude:
+    - bin/*
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - bin/*
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - bin/*
 
 Layout/LineLength:
   Max: 200
@@ -55,7 +70,7 @@ Lint/UnusedMethodArgument:
 Style/BlockComments:
   Enabled: false
   Include:
-    - "**/spec/*"
+    - "**/spec/**/*"
 
 # My Preferences - Start
 Metrics/ClassLength:
@@ -75,8 +90,8 @@ Style/EmptyMethod:
   Exclude:
     - "**/spec/**/*"
 Metrics/ParameterLists:
-  Exclude:
-    - "**/spec/**/*"
+  Enabled: false
+
 Layout/EmptyLineBetweenDefs:
   Exclude:
     - "**/spec/**/*"

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+# [0.3.0](https://github.com/appydave/klue-langcraft/compare/v0.2.0...v0.3.0) (2024-10-26)
+
+
+### Bug Fixes
+
+* fix cop ([d77187a](https://github.com/appydave/klue-langcraft/commit/d77187ac59088b7ce6ca23630a06fbb007f05fb4))
+
+
+### Features
+
+* update cli for watch and process ([9f0eeb1](https://github.com/appydave/klue-langcraft/commit/9f0eeb1a9409f6734d4ab930ca5c3164b71446eb))
+
+# [0.2.0](https://github.com/appydave/klue-langcraft/compare/v0.1.1...v0.2.0) (2024-10-25)
+
+
+### Bug Fixes
+
+* fix ci issue ([a3bfd35](https://github.com/appydave/klue-langcraft/commit/a3bfd35371b7c0ca70b0b57d70d4541c7a4ec54b))
+* fix cop ([123070b](https://github.com/appydave/klue-langcraft/commit/123070bd1f636a81d01da469c2e5072c57384bae))
+* update dsl_interpreter ([2507045](https://github.com/appydave/klue-langcraft/commit/2507045c3f7f205603a3f899785e9c5445c4c0bb))
+
+
+### Features
+
+* refactor dsl processor ([5875dc9](https://github.com/appydave/klue-langcraft/commit/5875dc957789f113da762a6dcb55cda66bfb8a3d))
+
 ## [0.1.1](https://github.com/appydave/klue-langcraft/compare/v0.1.0...v0.1.1) (2024-09-22)
 
 

data/bin/langcraft.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'klue/langcraft'
+require 'optparse'
+
+# CLI class for the Klue Langcraft application.
+# This class handles command-line interactions, parsing options,
+# and executing the appropriate commands for processing files
+# or watching directories.
+class CLI
+  def initialize
+    @commands = {
+      'process' => method(:process_files),
+      'watch' => method(:watch_files)
+    }
+  end
+
+  def run
+    if ARGV.empty?
+      print_help
+      exit
+    end
+
+    command, *args = ARGV
+    if @commands.key?(command)
+      @commands[command].call(args)
+    else
+      puts "Unknown command: #{command}"
+      print_help
+    end
+  end
+
+  private
+
+  def process_files(args)
+    options = {}
+    parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: langcraft process [options]'
+
+      opts.on('-i', '--input FILE', 'Input file (required)') do |file|
+        options[:input] = file
+      end
+
+      opts.on('-b', '--basic-output FILE', 'Output file') do |file|
+        options[:basic_output] = file
+      end
+
+      opts.on('-e', '--enhanced-output FILE', 'Output file') do |file|
+        options[:enhanced_output] = file
+      end
+
+      opts.on('-u', '--webhook-url URL', 'Webhook URL') do |url|
+        options[:webhook_url] = url
+      end
+
+      opts.on('-d', '--debug LEVEL', %i[none info detailed], 'Debug level (none, info, detailed)') do |level|
+        options[:debug] = level
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end
+
+    parser.parse!(args)
+
+    if validate_options(options)
+      run_klue_runner(options)
+    else
+      print_usage(parser)
+    end
+  end
+
+  def validate_options(options)
+    if options[:input].nil?
+      puts 'Error: Input file is required.'
+      false
+    else
+      true
+    end
+  end
+
+  def run_klue_runner(options)
+    klue_runner = Klue::Langcraft::DSL::KlueRunner.new
+    klue_runner.run(
+      input_file: options[:input],
+      basic_output_file: options[:basic_output],
+      enhanced_output_file: options[:enhanced_output],
+      webhook_url: options[:webhook_url],
+      debug: options[:debug] || :none
+    )
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+
+  def print_usage(parser)
+    puts 'Error: Invalid or missing options.'
+    puts
+    puts parser
+    exit 1
+  end
+
+  def watch_files(args)
+    options = {
+      directories: [],
+      create_basic_json: false,
+      create_enhanced_json: false,
+      log_level: :info,
+      webhook_url: nil,
+      extensions: ['.klue'] # Default extension
+    }
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: server watch [options]'
+
+      opts.on('-w', '--watch-directory DIRECTORY', 'Directory to watch (can be specified multiple times)') do |dir|
+        options[:directories] << File.expand_path(dir) # Expand the path here
+      end
+
+      opts.on('-f', '--flags TYPE', 'Set processing flags (none, basic, enhanced, all)') do |type|
+        types = type.split(',').map(&:strip).map(&:downcase)
+        options[:create_basic_json] = types.include?('basic') || types.include?('all')
+        options[:create_enhanced_json] = types.include?('enhanced') || types.include?('all')
+      end
+
+      opts.on('-l', '--log-level LEVEL', %i[none info detailed], 'Log level (none, info, detailed)') do |level|
+        options[:log_level] = level
+      end
+
+      opts.on('-u', '--webhook-url URL', 'Webhook URL') do |url|
+        options[:webhook_url] = url
+      end
+
+      opts.on('-e', '--extensions EXT1,EXT2,...', Array, 'File extensions to watch (default: .klue)') do |exts|
+        options[:extensions] = exts.map { |ext| ext.start_with?('.') ? ext : ".#{ext}" }
+      end
+
+      opts.on('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end.parse!(args)
+
+    # If no directories were specified, use the current directory
+    options[:directories] = [Dir.pwd] if options[:directories].empty?
+
+    # Ensure all directories are expanded
+    options[:directories].map! { |dir| File.expand_path(dir) }
+
+    Klue::Langcraft::DSL::Watcher.new(
+      options[:directories],
+      create_basic_json: options[:create_basic_json],
+      create_enhanced_json: options[:create_enhanced_json],
+      log_level: options[:log_level],
+      webhook_url: options[:webhook_url],
+      extensions: options[:extensions]
+    ).start
+  end
+
+  def print_help
+    puts 'Klue Langcraft Server'
+    puts 'Usage: server [command] [options]'
+    puts ''
+    puts 'Commands:'
+    puts '  process  Process a single file'
+    puts '  watch    Watch directories for changes'
+    puts ''
+    puts "Run 'server [command] --help' for more information on a command."
+  end
+end
+
+# Run the CLI
+CLI.new.run

data/lib/klue/langcraft/dsl/interpreter.rb

@@ -17,18 +17,18 @@ module Klue
         attr_accessor :processed
 
         def initialize
-          @data = {}
-          @processed = false
+          klue_reset
         end
 
         def process(input: nil, input_file: nil, output_file: nil)
-          validate_input_arguments(input, input_file)
-          input_content = input_content(input, input_file)
+          klue_reset
+          klue_validate_input_arguments(input, input_file)
+          klue_input_content = klue_input_content(input, input_file)
 
           @processed = true
-          instance_eval(input_content)
+          instance_eval(klue_input_content)
 
-          write_output(output_file) if output_file
+          klue_write_output(output_file) if output_file
           data
         end
 
@@ -36,7 +36,7 @@ module Klue
           raise "You must call 'process' before using other methods" unless @processed
 
           key = method_name
-          value = process_args(args, block)
+          value = klue_process_args(args, block)
 
           if @data[key]
             @data[key] = [@data[key]] unless @data[key].is_a?(Array)
@@ -50,7 +50,7 @@ module Klue
           @processed || super
         end
 
-        def process_args(args, block)
+        def klue_process_args(args, block)
           positional_args = []
           named_args = {}
 
@@ -82,32 +82,32 @@ module Klue
 
         private
 
-        def validate_input_arguments(input, input_file)
+        def klue_reset
+          @data = {}
+          @processed = false
+        end
+
+        def klue_validate_input_arguments(input, input_file)
           raise ArgumentError, 'Either input or input_file must be provided' unless input || input_file
           raise ArgumentError, 'Both input and input_file cannot be provided' if input && input_file
         end
 
-        def input_content(input, input_file)
+        def klue_input_content(input, input_file)
           input_file ? File.read(input_file) : input
         end
 
-        def write_output(output_file)
-          output_path = get_output_path(output_file)
+        def klue_write_output(output_file)
+          output_path = klue_output_path(output_file)
           File.write(output_path, JSON.pretty_generate(data))
         end
 
-        def get_output_path(output_file)
+        def klue_output_path(output_file)
           if Pathname.new(output_file).absolute?
             output_file
           else
             File.join(File.dirname(output_file), File.basename(output_file))
           end
         end
-
-        # Convert to JSON
-        def to_json(*_args)
-          @data.to_json
-        end
       end
     end
   end

data/lib/klue/langcraft/dsl/klue_runner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Klue
+  module Langcraft
+    module DSL
+      # KlueRunner handles the processing of DSL input data
+      # It manages the execution of various processors and the output of processed data
+      class KlueRunner
+        attr_reader :interpreter, :pipeline, :webhook
+
+        def initialize
+          @interpreter = Klue::Langcraft::DSL::Interpreter.new
+          @pipeline = Klue::Langcraft::DSL::ProcessDataPipeline.new(Klue::Langcraft::DSL::ProcessMatcher.new)
+          @webhook = Klue::Langcraft::DSL::Webhook.new
+        end
+
+        # Run the KlueRunner with the given input data
+        # @param input [String] The input data to process
+        # @param input_file [String] The input file to process (input data and file are mutually exclusive)
+        # @param basic_output_file [String] The output file to write the processed data, this file is before any processing
+        # @param enhanced_output_file [String] The output file to write the processed data, this file is after processing
+        def run(
+          input: nil,
+          input_file: nil,
+          basic_output_file: nil,
+          enhanced_output_file: nil,
+          webhook_url: nil,
+          log_level: :none
+        )
+          @log_level = log_level
+
+          log_info('Processing input')
+          data = interpreter.process(input: input, input_file: input_file, output_file: basic_output_file)
+          log_detailed('Interpreter output:', data)
+
+          log_info('Executing pipeline - enhance')
+          enhanced_data = pipeline.execute(data)
+          log_detailed('Enhanced output:', enhanced_data)
+
+          if enhanced_output_file
+            log_info("Writing enhanced output to file: #{enhanced_output_file}")
+            @pipeline.write_output(enhanced_data, enhanced_output_file)
+          end
+
+          if webhook_url
+            log_info("Delivering data to webhook: #{webhook_url}")
+            @webhook.deliver(webhook_url, enhanced_data)
+          end
+
+          log_info('Processing complete')
+        end
+
+        private
+
+        def log_info(message)
+          puts message if %i[info detailed].include?(@log_level)
+        end
+
+        def log_detailed(message, data)
+          return unless @log_level == :detailed
+
+          puts message
+          pp data
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/dsl/watcher.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'listen'
+
+module Klue
+  module Langcraft
+    module DSL
+      # Watcher class for monitoring file changes in specified directories.
+      # This class sets up a file system listener to watch for changes to files
+      # with specified extensions, and processes those files using a KlueRunner.
+      class Watcher
+        def initialize(directories, **options)
+          @directories = directories.map { |dir| File.expand_path(dir) }
+          @options = options
+          @klue_runner = Klue::Langcraft::DSL::KlueRunner.new
+          @extensions = options[:extensions] || ['.klue']
+        end
+
+        def start
+          listener = create_listener
+          log_watcher_info
+          listener.start
+          sleep
+        end
+
+        private
+
+        def create_listener
+          extension_regex = create_extension_regex
+          Listen.to(*@directories, only: extension_regex) do |modified, added, _removed|
+            process_changed_files(modified + added)
+          end
+        end
+
+        def create_extension_regex
+          Regexp.union(@extensions.map { |ext| /#{Regexp.escape(ext)}$/ })
+        end
+
+        def process_changed_files(files)
+          files.each { |file| process_file(file) }
+        end
+
+        def process_file(file)
+          log_info('Processing file', file)
+          options = create_file_options(file)
+          run_klue_runner(options)
+        rescue StandardError => e
+          log_error('Error processing file', "#{file}: #{e.message}")
+        end
+
+        def create_file_options(file)
+          options = @options.dup
+          options[:input_file] = file
+          options[:basic_output_file] = file.sub(/#{File.extname(file)}$/, '.json') if @options[:create_basic_json]
+          options[:enhanced_output_file] = file.sub(/#{File.extname(file)}$/, '.enhanced.json') if @options[:create_enhanced_json]
+          options
+        end
+
+        def run_klue_runner(options)
+          @klue_runner.run(
+            input_file: options[:input_file],
+            basic_output_file: options[:basic_output_file],
+            enhanced_output_file: options[:enhanced_output_file],
+            webhook_url: options[:webhook_url],
+            log_level: options[:log_level]
+          )
+        end
+
+        def log_watcher_info
+          log_info('Watching directories', @directories.join(', '))
+          log_info('Watching file extensions', @extensions.join(', '))
+          log_info('Create basic JSON', @options[:create_basic_json])
+          log_info('Create enhanced JSON', @options[:create_enhanced_json])
+          log_info('Webhook URL', @options[:webhook_url])
+          log_info('Log level', @options[:log_level])
+        end
+
+        def log_info(label, value)
+          puts "#{label.ljust(30)}: #{value}" if %i[info detailed].include?(@options[:log_level])
+        end
+
+        def log_error(label, value)
+          puts "#{label.ljust(30)}: #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/dsl/webhook.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Klue
+  module Langcraft
+    module DSL
+      # Webhook class for handling HTTP POST requests to specified URLs.
+      # This class is responsible for sending processed data to external services
+      # via webhooks, handling the delivery process, and logging the results.
+      class Webhook
+        def deliver(webhook_url, data)
+          klue_type = extract_klue_type(data)
+          uri = build_uri(webhook_url, klue_type)
+          response = send_request(uri, build_payload(klue_type, data))
+          log_response(response, uri)
+          response
+        end
+
+        private
+
+        def extract_klue_type(data)
+          data.keys.first.to_s
+        end
+
+        def build_uri(webhook_url, klue_type)
+          URI.parse("#{webhook_url}?klue-type=#{klue_type}")
+        end
+
+        def build_payload(klue_type, data)
+          { klue_type: klue_type, data: data }
+        end
+
+        def send_request(uri, payload)
+          http = Net::HTTP.new(uri.host, uri.port)
+          request = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
+          request.body = payload.to_json
+          http.request(request)
+        end
+
+        def log_response(response, uri)
+          puts "Response: #{response.code} - #{response.message}"
+          puts "Endpoint: #{uri}"
+          log_response_body(response)
+        end
+
+        def log_response_body(response)
+          body = JSON.parse(response.body)
+          puts "DSL Type: #{body['type']}"
+          # puts JSON.pretty_generate(body['data'])
+        end
+      end
+    end
+  end
+end

data/lib/klue/langcraft/version.rb

@@ -2,6 +2,6 @@
 
 module Klue
   module Langcraft
-    VERSION = '0.2.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/klue/langcraft.rb

@@ -19,12 +19,9 @@ require 'klue/langcraft/dsl/processors/full_name_processor'
 require 'klue/langcraft/dsl/interpreter'
 require 'klue/langcraft/dsl/process_matcher'
 require 'klue/langcraft/dsl/process_data_pipeline'
-
-require 'base_process'
-require 'process_file_collector'
-require 'dsl_interpreter'
-require 'dsl_folder_watcher'
-require 'dsl_process_data'
+require 'klue/langcraft/dsl/webhook'
+require 'klue/langcraft/dsl/watcher'
+require 'klue/langcraft/dsl/klue_runner'
 
 module Klue
   module Langcraft

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "klue-langcraft",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "klue-langcraft",
-      "version": "0.2.0",
+      "version": "0.4.0",
       "devDependencies": {
         "@klueless-js/semantic-release-rubygem": "github:klueless-js/semantic-release-rubygem",
         "@semantic-release/changelog": "^6.0.3",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klue-langcraft",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Domain Specific Language Crafting",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: klue-langcraft
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-25 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appydave-tools
@@ -61,7 +61,7 @@ files:
 - README.md
 - Rakefile
 - bin/console
-- bin/dsl_watcher.rb
+- bin/langcraft.rb
 - bin/setup
 - docs/dsl-class-diagram.md
 - docs/dsl-examples.md
@@ -78,24 +78,22 @@ files:
 - docs/project-plan/project_done.svg
 - docs/project-plan/project_in_progress.svg
 - docs/project-plan/project_todo.svg
-- lib/base_process.rb
-- lib/dsl_folder_watcher.rb
-- lib/dsl_interpreter.rb
-- lib/dsl_process_data.rb
 - lib/klue/langcraft.rb
 - lib/klue/langcraft/dsl/interpreter.rb
+- lib/klue/langcraft/dsl/klue_runner.rb
 - lib/klue/langcraft/dsl/process_data_pipeline.rb
 - lib/klue/langcraft/dsl/process_matcher.rb
 - lib/klue/langcraft/dsl/processor_config.rb
 - lib/klue/langcraft/dsl/processors/file_collector_processor.rb
 - lib/klue/langcraft/dsl/processors/full_name_processor.rb
 - lib/klue/langcraft/dsl/processors/processor.rb
+- lib/klue/langcraft/dsl/watcher.rb
+- lib/klue/langcraft/dsl/webhook.rb
 - lib/klue/langcraft/tokenizer-old-needs-revisit/-brief.md
 - lib/klue/langcraft/tokenizer-old-needs-revisit/parser.rb
 - lib/klue/langcraft/tokenizer-old-needs-revisit/sample_usage.rb
 - lib/klue/langcraft/tokenizer-old-needs-revisit/tokenizer.rb
 - lib/klue/langcraft/version.rb
-- lib/process_file_collector.rb
 - package-lock.json
 - package.json
 - sig/klue/langcraft.rbs

data/bin/dsl_watcher.rb

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-
-require 'klue/langcraft'
-
-BASE_PATH = ARGV[0] || '/Users/davidcruwys/dev/appydave/klueless'
-
-DSLFolderWatcher.watch(BASE_PATH)

data/lib/base_process.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# file: lib/base_process.rb
-
-class BaseProcess
-  attr_reader :key
-
-  def initialize(key)
-    @key = key
-  end
-
-  def deep_match(input, predicate)
-    matches = []
-
-    # If the current input is a Hash, iterate over each key-value pair
-    if input.is_a?(Hash)
-
-      input.each do |key, value|
-
-        # If the value matches the predicate, add it to matches
-        if predicate.call(key, value)
-          matches << value
-        end
-
-        # Continue searching deeper within the value
-        matches.concat(deep_match(value, predicate))
-      end
-
-    # If the input is an Array, iterate over each item
-    elsif input.is_a?(Array)
-
-      input.each do |item|
-
-        # Continue searching within each item of the array
-        matches.concat(deep_match(item, predicate))
-      end
-    end
-
-    matches
-  end
-end

data/lib/dsl_folder_watcher.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class DSLFolderWatcher
-  def self.watch(folder_path)
-    puts "Watching: #{folder_path}"
-    listener = Listen.to(folder_path) do |modified, added, _removed|
-      changes = (modified + added).uniq
-
-      # DEBOUNCE CURRENTLY NOT WORKING
-      # debounce_map = {}
-      # debounce_interval = 1 # seconds
-
-      changes.each do |file_path|
-        next unless File.extname(file_path) == '.klue'
-
-        puts file_path
-
-        # debounce_map[file_path] ||= Time.now
-        # next unless Time.now - debounce_map[file_path] >= debounce_interval
-
-        # debounce_map[file_path] = Time.now
-
-        base_name = file_path.gsub(/\.klue$/, '')
-        input_file = "#{base_name}.klue"
-        output_file = "#{base_name}.json"
-
-        interpreter = DSLInterpreter.new
-        if interpreter.process('', input_file, output_file)
-          # Process the JSON data to add 'process-data' details
-          dsl_processor = DSLProcessData.new
-          dsl_processor.process('', output_file, output_file)
-          # SKIP EXTEND FILE FOR NOW AND REWRITE THE OUTPUTFILE
-          # dsl_processor.process('', output_file, extended_output_file)
-
-          # interpreter.send_to_endpoint
-        else
-          puts 'Skipping further processing due to errors in DSL interpretation.'
-        end
-      end
-
-      # Remove old entries from debounce_map to prevent memory bloat
-      # debounce_map.each_key do |key|
-      #   debounce_map.delete(key) if Time.now - debounce_map[key] > debounce_interval * 2
-      # end
-    end
-    listener.start
-    puts "Wait for changes: #{folder_path}"
-    sleep
-  end
-end

data/lib/dsl_interpreter.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-# ChatReferences:
-# - https://chatgpt.com/c/67064770-d524-8002-8344-3091e895d150
-# - https://chatgpt.com/c/6706289c-9b9c-8002-86e3-f9198c1c608a
-# - https://chatgpt.com/c/670dcd34-5dbc-8002-ad7a-d4df54a6a2e0
-#
-class DSLInterpreter
-  def initialize
-    @data = {}
-  end
-
-  # Capturing top-level DSL methods
-  def method_missing(method_name, *args, &block)
-    key = method_name
-    value = process_args(args, block)
-
-    # Append key-value to the current context of @data
-    if @data[key]
-      @data[key] = [@data[key]] unless @data[key].is_a?(Array)
-      @data[key] << value
-    else
-      @data[key] = value
-    end
-  end
-
-  # A method to handle parameters and nested blocks
-  def process_args(args, block)
-    data = {}
-
-    # Handling positional and named parameters separately
-    positional_args = []
-    named_args = {}
-
-    args.each do |arg|
-      if arg.is_a?(Hash)
-        named_args.merge!(arg)
-      else
-        positional_args << arg
-      end
-    end
-
-    # Assign positional parameters generically
-    positional_args.each_with_index do |arg, index|
-      data[:"param#{index + 1}"] = arg
-    end
-
-    # Merge named parameters directly
-    data.merge!(named_args)
-
-    # Handling a nested block
-    if block
-      interpreter = DSLInterpreter.new
-      interpreter.instance_eval(&block)
-      data.merge!(interpreter.data)
-    end
-
-    data.empty? ? nil : data
-  end
-
-  # To access data after interpreting
-  attr_reader :data
-
-  # Reading file and evaluating as Ruby
-  def process(base_path, input_file, output_file)
-    file_path = File.join(base_path, input_file)
-    content = File.read(file_path)
-
-    # begin
-    instance_eval(content)
-    # rescue SyntaxError => e
-    #   puts "Syntax error in DSL file: #{input_file}"
-    #   puts "Error message: #{e.message}"
-    #   puts "Error occurred at line: #{e.backtrace.first}"
-    #   return false  # Indicate that processing failed
-    # rescue StandardError => e
-    #   puts "Error processing DSL file: #{input_file}"
-    #   puts "Error message: #{e.message}"
-    #   puts "Error occurred at: #{e.backtrace.first}"
-    #   return false  # Indicate that processing failed
-    # end
-
-    output_path = File.join(base_path, output_file)
-    File.write(output_path, JSON.pretty_generate(to_hash))
-    true # Indicate that processing succeeded
-  end
-
-  # Convert to hash or JSON as required
-  def to_hash
-    @data
-  end
-
-  def to_json(*_args)
-    @data.to_json
-  end
-
-  # Method to send data to an endpoint
-  def send_to_endpoint
-    root_key = @data.keys.first
-    action_type = root_key.to_s
-
-    uri = URI.parse("http://localhost:4567/dsl/#{action_type}")
-    http = Net::HTTP.new(uri.host, uri.port)
-    request = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
-    payload = { action_type: action_type, data: @data }
-    request.body = payload.to_json
-
-    response = http.request(request)
-    puts "Response: #{response.code} - #{response.message}"
-    puts "Endpoint: #{uri}"
-  end
-end

data/lib/dsl_process_data.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class DSLProcessData
-  PROCESSORS = [{ file_collector: ProcessFileCollector }].freeze
-
-  # Method to process the JSON file after initial evaluation
-  def process(base_path, input_file, output_file)
-    json_file_path = File.join(base_path, input_file)
-    data = JSON.parse(File.read(json_file_path))
-
-    # Loop through the processors and execute matching ones
-    PROCESSORS.each do |processor_entry|
-      key, processor_class = processor_entry.first
-      processor = processor_class.new(key)
-
-      next unless processor.match?(data)
-
-      result = processor.execute(data)
-
-      data['process-data'] ||= {}
-
-      result.each do |key, result|
-        data['process-data'][key.to_s] = result unless result.empty?
-      end
-    end
-
-    # Write the updated JSON data to an extended file
-    extended_output_file = File.join(base_path, output_file)
-    File.write(extended_output_file, JSON.pretty_generate(data))
-  end
-end

data/lib/process_file_collector.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-# file: lib/process_file_collector.rb
-
-class ProcessFileCollector < BaseProcess
-  def initialize(key)
-    super
-    @found = nil
-    # @matcher = ->(key, value) { key.to_s == 'file_collector' && value.is_a?(Hash) }
-    @matcher = lambda do |key, value|
-      if key.to_s == 'file_collector'
-        if value.is_a?(Array)
-          value.any? { |v| v.is_a?(Hash) }
-        else
-          value.is_a?(Hash)
-        end
-      else
-        false
-      end
-    end
-  end
-
-  def match?(input)
-    @found = deep_match(input, @matcher)
-    !@found.empty?
-  end
-
-  def execute(_input)
-    # Iterate over each `file_collector` found and process individually
-    results = {}
-
-    @found.each do |data|
-      next unless data.is_a?(Hash)
-
-      # Extract the `as` key if present
-      as_key = data['as']
-
-      working_directory = File.expand_path(data['root'])
-
-      options = Appydave::Tools::GptContext::Options.new(
-        working_directory: working_directory,
-        include_patterns: extract_patterns(data.dig('files', 'include')),
-        exclude_patterns: extract_patterns(data.dig('files', 'exclude')),
-        format: 'json',
-        line_limit: data['line_length']
-      )
-
-      collector = Appydave::Tools::GptContext::FileCollector.new(options)
-      json = collector.build
-
-      # Structuring the result under `process-data` with `as` as key
-      result_data = {
-        type: 'file_collector',
-        data: {
-          working_directory: working_directory,
-          files: JSON.parse(json)
-        }
-      }
-
-      # If `as` key exists, use it to store under process-data with that identifier
-      if as_key
-        results[as_key] = result_data
-      else
-        # Generate a unique key if no `as` key is defined
-        unique_key = "file_collector_#{results.size + 1}"
-        results[unique_key] = result_data
-      end
-    end
-
-    results
-  rescue SyntaxError, NameError, NoMethodError => e
-    puts "Ruby evaluation error in ProcessFileCollector: #{e.message}"
-    puts "Error occurred at: #{e.backtrace.first}"
-    {}
-  rescue StandardError => e
-    puts "Unexpected error in ProcessFileCollector: #{e.message}"
-    puts e.backtrace.join("\n")
-    {}
-  end
-
-  private
-
-  def extract_patterns(files_data)
-    if files_data.is_a?(Hash)
-      [files_data['param1']]
-    elsif files_data.is_a?(Array)
-      files_data.map { |entry| entry['param1'] }
-    else
-      []
-    end
-  end
-end