fluyenta-ruby 0.1.14

data/lib/brainzlab/debug.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  # Debug module for SDK operation logging
+  #
+  # Provides pretty-printed debug output for all SDK operations when debug mode is enabled.
+  # Includes timing information and request/response details.
+  #
+  # @example Enable debug mode
+  #   BrainzLab.configure do |config|
+  #     config.debug = true
+  #   end
+  #
+  # @example Use custom logger
+  #   BrainzLab.configure do |config|
+  #     config.debug = true
+  #     config.logger = Logger.new(STDOUT)
+  #   end
+  #
+  # @example Manual debug logging
+  #   BrainzLab::Debug.log("Custom message", level: :info)
+  #
+  module Debug
+    COLORS = {
+      reset: "\e[0m",
+      bold: "\e[1m",
+      dim: "\e[2m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      magenta: "\e[35m",
+      cyan: "\e[36m",
+      white: "\e[37m",
+      gray: "\e[90m"
+    }.freeze
+
+    LEVEL_COLORS = {
+      debug: :gray,
+      info: :cyan,
+      warn: :yellow,
+      error: :red,
+      fatal: :red
+    }.freeze
+
+    LEVEL_LABELS = {
+      debug: 'DEBUG',
+      info: 'INFO',
+      warn: 'WARN',
+      error: 'ERROR',
+      fatal: 'FATAL'
+    }.freeze
+
+    class << self
+      # Log a debug message if debug mode is enabled
+      #
+      # @param message [String] The message to log
+      # @param level [Symbol] Log level (:debug, :info, :warn, :error, :fatal)
+      # @param data [Hash] Optional additional data to include
+      # @return [void]
+      def log(message, level: :info, **data)
+        return unless enabled?
+
+        output = format_message(message, level: level, **data)
+        write_output(output, level: level)
+      end
+
+      # Log an outgoing request
+      #
+      # @param service [String, Symbol] The service name (e.g., :recall, :reflex)
+      # @param method [String] HTTP method
+      # @param path [String] Request path
+      # @param data [Hash] Request payload summary
+      # @return [void]
+      def log_request(service, method, path, data: nil)
+        return unless enabled?
+
+        data_summary = summarize_data(data) if data
+        message = data_summary ? "#{method} #{path} #{data_summary}" : "#{method} #{path}"
+
+        output = format_arrow_message(:out, service, message)
+        write_output(output, level: :info)
+      end
+
+      # Log an incoming response
+      #
+      # @param service [String, Symbol] The service name
+      # @param status [Integer] HTTP status code
+      # @param duration_ms [Float] Request duration in milliseconds
+      # @param error [String, nil] Error message if request failed
+      # @return [void]
+      def log_response(service, status, duration_ms, error: nil)
+        return unless enabled?
+
+        status_text = status_message(status)
+        duration_text = format_duration(duration_ms)
+
+        message = if error
+                    "#{status} #{status_text} (#{duration_text}) - #{error}"
+                  else
+                    "#{status} #{status_text} (#{duration_text})"
+                  end
+
+        level = status >= 400 ? :error : :info
+        output = format_arrow_message(:in, service, message, level: level)
+        write_output(output, level: level)
+      end
+
+      # Log an SDK operation with timing
+      #
+      # @param service [String, Symbol] The service name
+      # @param operation [String] Operation description
+      # @param data [Hash] Operation data
+      # @return [void]
+      def log_operation(service, operation, **data)
+        return unless enabled?
+
+        data_summary = data.empty? ? '' : " (#{format_data_inline(data)})"
+        message = "#{operation}#{data_summary}"
+
+        output = format_arrow_message(:out, service, message)
+        write_output(output, level: :info)
+      end
+
+      # Measure and log execution time of a block
+      #
+      # @param service [String, Symbol] The service name
+      # @param operation [String] Operation description
+      # @yield Block to measure
+      # @return [Object] Result of the block
+      def measure(service, operation)
+        return yield unless enabled?
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        log_operation(service, operation)
+
+        result = yield
+
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+        log("#{operation} completed", level: :debug, duration_ms: duration_ms, service: service.to_s)
+
+        result
+      rescue StandardError => e
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+        log("#{operation} failed: #{e.message}", level: :error, duration_ms: duration_ms, service: service.to_s)
+        raise
+      end
+
+      # Check if debug mode is enabled
+      #
+      # @return [Boolean]
+      def enabled?
+        BrainzLab.configuration.debug?
+      end
+
+      # Check if colorized output should be used
+      #
+      # @return [Boolean]
+      def colorize?
+        return false unless enabled?
+        return @colorize if defined?(@colorize)
+
+        @colorize = $stdout.tty?
+      end
+
+      # Reset colorize detection (useful for testing)
+      def reset_colorize!
+        remove_instance_variable(:@colorize) if defined?(@colorize)
+      end
+
+      private
+
+      def format_message(message, level:, **data)
+        timestamp = format_timestamp
+        prefix = colorize("[BrainzLab]", :bold, :blue)
+        level_badge = format_level(level)
+        data_str = data.empty? ? '' : " #{format_data(data)}"
+
+        "#{prefix} #{timestamp} #{level_badge} #{message}#{data_str}"
+      end
+
+      def format_arrow_message(direction, service, message, level: :info)
+        timestamp = format_timestamp
+        prefix = colorize("[BrainzLab]", :bold, :blue)
+        arrow = direction == :out ? colorize("->", :cyan) : colorize("<-", :green)
+        service_name = colorize(service.to_s.capitalize, :magenta)
+
+        "#{prefix} #{timestamp} #{arrow} #{service_name} #{message}"
+      end
+
+      def format_timestamp
+        time = Time.now.strftime('%H:%M:%S')
+        colorize(time, :dim)
+      end
+
+      def format_level(level)
+        label = LEVEL_LABELS[level] || level.to_s.upcase
+        color = LEVEL_COLORS[level] || :white
+        colorize("[#{label}]", color)
+      end
+
+      def format_duration(ms)
+        if ms < 1
+          colorize("#{(ms * 1000).round(0)}us", :green)
+        elsif ms < 100
+          colorize("#{ms.round(1)}ms", :green)
+        elsif ms < 1000
+          colorize("#{ms.round(0)}ms", :yellow)
+        else
+          colorize("#{(ms / 1000.0).round(2)}s", :red)
+        end
+      end
+
+      def format_data(data)
+        pairs = data.map { |k, v| "#{k}: #{format_value(v)}" }
+        colorize("(#{pairs.join(', ')})", :dim)
+      end
+
+      def format_data_inline(data)
+        data.map { |k, v| "#{k}: #{format_value(v)}" }.join(', ')
+      end
+
+      def format_value(value)
+        case value
+        when String
+          value.length > 50 ? "#{value[0..47]}..." : value
+        when Hash
+          "{#{value.keys.join(', ')}}"
+        when Array
+          "[#{value.length} items]"
+        else
+          value.to_s
+        end
+      end
+
+      def summarize_data(data)
+        return nil unless data.is_a?(Hash)
+
+        summary_parts = []
+        summary_parts << "\"#{truncate(data[:message] || data['message'], 30)}\"" if data[:message] || data['message']
+
+        other_keys = data.keys.reject { |k| %i[message timestamp level].include?(k.to_sym) }
+        if other_keys.any?
+          key_summary = other_keys.take(3).map { |k| "#{k}: #{format_value(data[k])}" }.join(', ')
+          key_summary += ", ..." if other_keys.length > 3
+          summary_parts << "(#{key_summary})"
+        end
+
+        summary_parts.join(' ')
+      end
+
+      def truncate(str, length)
+        return '' unless str
+
+        str = str.to_s
+        str.length > length ? "#{str[0..length - 4]}..." : str
+      end
+
+      def status_message(status)
+        case status
+        when 200 then 'OK'
+        when 201 then 'Created'
+        when 204 then 'No Content'
+        when 400 then 'Bad Request'
+        when 401 then 'Unauthorized'
+        when 403 then 'Forbidden'
+        when 404 then 'Not Found'
+        when 422 then 'Unprocessable Entity'
+        when 429 then 'Too Many Requests'
+        when 500 then 'Internal Server Error'
+        when 502 then 'Bad Gateway'
+        when 503 then 'Service Unavailable'
+        else ''
+        end
+      end
+
+      def colorize(text, *colors)
+        return text unless colorize?
+
+        color_codes = colors.map { |c| COLORS[c] }.compact.join
+        "#{color_codes}#{text}#{COLORS[:reset]}"
+      end
+
+      def write_output(output, level:)
+        config = BrainzLab.configuration
+
+        if config.logger
+          case level
+          when :debug then config.logger.debug(strip_colors(output))
+          when :info then config.logger.info(strip_colors(output))
+          when :warn then config.logger.warn(strip_colors(output))
+          when :error, :fatal then config.logger.error(strip_colors(output))
+          else config.logger.info(strip_colors(output))
+          end
+        else
+          $stderr.puts output
+        end
+      end
+
+      def strip_colors(text)
+        text.gsub(/\e\[\d+m/, '')
+      end
+    end
+  end
+end

data/lib/brainzlab/dendrite/client.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'cgi'
+
+module BrainzLab
+  module Dendrite
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.dendrite_url || 'https://dendrite.brainzlab.ai'
+      end
+
+      # Connect a repository
+      def connect_repository(url:, name: nil, branch: 'main', **options)
+        response = request(
+          :post,
+          '/api/v1/repositories',
+          body: {
+            url: url,
+            name: name,
+            branch: branch,
+            **options
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('connect_repository', e)
+        nil
+      end
+
+      # Trigger sync for a repository
+      def sync_repository(repo_id)
+        response = request(:post, "/api/v1/repositories/#{repo_id}/sync")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error('sync_repository', e)
+        false
+      end
+
+      # Get repository status
+      def get_repository(repo_id)
+        response = request(:get, "/api/v1/repositories/#{repo_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('get_repository', e)
+        nil
+      end
+
+      # List repositories
+      def list_repositories
+        response = request(:get, '/api/v1/repositories')
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:repositories] || []
+      rescue StandardError => e
+        log_error('list_repositories', e)
+        []
+      end
+
+      # Get wiki pages for a repository
+      def get_wiki(repo_id)
+        response = request(:get, "/api/v1/wiki/#{repo_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('get_wiki', e)
+        nil
+      end
+
+      # Get a specific wiki page
+      def get_wiki_page(repo_id, page_slug)
+        response = request(:get, "/api/v1/wiki/#{repo_id}/#{CGI.escape(page_slug)}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('get_wiki_page', e)
+        nil
+      end
+
+      # Semantic search across codebase
+      def search(repo_id, query, limit: 10)
+        response = request(
+          :get,
+          '/api/v1/search',
+          params: { repo_id: repo_id, q: query, limit: limit }
+        )
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:results] || []
+      rescue StandardError => e
+        log_error('search', e)
+        []
+      end
+
+      # Ask a question about the codebase
+      def ask(repo_id, question, session_id: nil)
+        response = request(
+          :post,
+          '/api/v1/chat',
+          body: {
+            repo_id: repo_id,
+            question: question,
+            session_id: session_id
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('ask', e)
+        nil
+      end
+
+      # Explain a specific file or function
+      def explain(repo_id, path, symbol: nil)
+        response = request(
+          :post,
+          '/api/v1/explain',
+          body: {
+            repo_id: repo_id,
+            path: path,
+            symbol: symbol
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('explain', e)
+        nil
+      end
+
+      # Generate a diagram
+      def generate_diagram(repo_id, type:, scope: nil)
+        response = request(
+          :post,
+          '/api/v1/diagrams',
+          body: {
+            repo_id: repo_id,
+            type: type, # class, er, sequence, architecture
+            scope: scope
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('generate_diagram', e)
+        nil
+      end
+
+      def provision(project_id:, app_name:)
+        response = request(
+          :post,
+          '/api/v1/projects/provision',
+          body: { project_id: project_id, app_name: app_name },
+          use_service_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error('provision', e)
+        false
+      end
+
+      private
+
+      def request(method, path, headers: {}, body: nil, params: nil, use_service_key: false)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        uri.query = URI.encode_www_form(params) if params
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 10
+        http.read_timeout = 60 # Longer timeout for AI operations
+
+        request = case method
+                  when :get
+                    Net::HTTP::Get.new(uri)
+                  when :post
+                    Net::HTTP::Post.new(uri)
+                  when :put
+                    Net::HTTP::Put.new(uri)
+                  when :delete
+                    Net::HTTP::Delete.new(uri)
+                  end
+
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = 'application/json'
+
+        if use_service_key
+          request['X-Service-Key'] = @config.dendrite_master_key || @config.secret_key
+        else
+          auth_key = @config.dendrite_api_key || @config.secret_key
+          request['Authorization'] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        structured_error = ErrorHandler.wrap(error, service: 'Dendrite', operation: operation)
+        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Dendrite', operation: operation })
+        end
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Dendrite', operation: operation)
+        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Dendrite', operation: operation })
+        end
+
+        structured_error
+      end
+    end
+  end
+end

data/lib/brainzlab/dendrite/provisioner.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Dendrite
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.dendrite_auto_provision
+        return unless valid_auth?
+
+        @provisioned = true
+
+        project_id = detect_project_id
+        return unless project_id
+
+        client = Client.new(@config)
+        client.provision(
+          project_id: project_id,
+          app_name: @config.app_name || @config.service
+        )
+
+        BrainzLab.debug_log("[Dendrite::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Dendrite::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.dendrite_api_key || @config.dendrite_master_key || @config.secret_key
+        !key.nil? && !key.empty?
+      end
+
+      def detect_project_id
+        ENV.fetch('BRAINZLAB_PROJECT_ID', nil)
+      end
+    end
+  end
+end