fluyenta-ruby 0.1.14

data/lib/brainzlab/vision.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative 'vision/client'
+require_relative 'vision/provisioner'
+
+module BrainzLab
+  module Vision
+    class << self
+      # Execute an autonomous AI task
+      # @param instruction [String] Natural language instruction for the AI
+      # @param start_url [String] URL to start from
+      # @param model [String] LLM model to use (default: claude-sonnet-4)
+      # @param browser_provider [String] Browser provider (default: local)
+      # @param max_steps [Integer] Maximum steps to execute (default: 50)
+      # @param timeout [Integer] Timeout in seconds (default: 300)
+      # @return [Hash] Task result with extracted data
+      def execute_task(instruction:, start_url:, model: nil, browser_provider: nil, max_steps: 50, timeout: 300)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+
+        ensure_provisioned!
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.execute_task(
+          instruction: instruction,
+          start_url: start_url,
+          model: model,
+          browser_provider: browser_provider,
+          max_steps: max_steps,
+          timeout: timeout
+        )
+      end
+
+      # Create a browser session
+      # @param url [String] Optional initial URL
+      # @param viewport [Hash] Viewport dimensions { width:, height: }
+      # @param browser_provider [String] Browser provider to use
+      # @return [Hash] Session info with session_id
+      def create_session(url: nil, viewport: nil, browser_provider: nil)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+
+        ensure_provisioned!
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.create_session(
+          url: url,
+          viewport: viewport,
+          browser_provider: browser_provider
+        )
+      end
+
+      # Perform an AI-powered action in a session
+      # @param session_id [String] Session ID
+      # @param instruction [String] Natural language instruction
+      # @param model [String] LLM model to use
+      # @return [Hash] Action result
+      def ai_action(session_id:, instruction:, model: nil)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.ai_action(
+          session_id: session_id,
+          instruction: instruction,
+          model: model
+        )
+      end
+
+      # Perform a direct browser action
+      # @param session_id [String] Session ID
+      # @param action [Symbol] Action type (:click, :type, :scroll, etc.)
+      # @param selector [String] Element selector
+      # @param value [String] Value for type/fill actions
+      # @return [Hash] Action result
+      def perform(session_id:, action:, selector: nil, value: nil)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.perform(
+          session_id: session_id,
+          action: action,
+          selector: selector,
+          value: value
+        )
+      end
+
+      # Extract structured data from the page
+      # @param session_id [String] Session ID
+      # @param schema [Hash] JSON schema for extraction
+      # @param instruction [String] Optional instruction for extraction
+      # @return [Hash] Extracted data
+      def extract(session_id:, schema:, instruction: nil)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.extract(
+          session_id: session_id,
+          schema: schema,
+          instruction: instruction
+        )
+      end
+
+      # Close a browser session
+      # @param session_id [String] Session ID
+      # @return [Hash] Close result
+      def close_session(session_id:)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.close_session(session_id: session_id)
+      end
+
+      # Take a screenshot
+      # @param session_id [String] Session ID
+      # @param full_page [Boolean] Capture full page (default: true)
+      # @return [Hash] Screenshot data
+      def screenshot(session_id:, full_page: true)
+        config = BrainzLab.configuration
+        return { error: 'Vision is not enabled' } unless config.vision_enabled
+        return { error: 'Vision credentials not configured' } unless config.vision_valid?
+
+        client.screenshot(session_id: session_id, full_page: full_page)
+      end
+
+      # Ensure project is auto-provisioned
+      def ensure_provisioned!
+        config = BrainzLab.configuration
+        puts "[BrainzLab::Debug] Vision.ensure_provisioned! called, @provisioned=#{@provisioned}" if config.debug
+
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+    end
+  end
+end

data/lib/brainzlab-sdk.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'brainzlab'

data/lib/brainzlab.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+# BrainzLab SDK - Official Ruby SDK for BrainzLab products
+#
+# For testing utilities, require 'brainzlab/testing' in your test helper:
+#
+#   require 'brainzlab/testing'
+#
+#   RSpec.configure do |config|
+#     config.include BrainzLab::Testing::Helpers
+#   end
+#
+# See BrainzLab::Testing for more details.
+
+require_relative 'brainzlab/version'
+require_relative 'brainzlab/errors'
+require_relative 'brainzlab/configuration'
+require_relative 'brainzlab/debug'
+require_relative 'brainzlab/context'
+require_relative 'brainzlab/recall'
+require_relative 'brainzlab/reflex'
+require_relative 'brainzlab/pulse'
+require_relative 'brainzlab/flux'
+require_relative 'brainzlab/signal'
+require_relative 'brainzlab/vault'
+require_relative 'brainzlab/vision'
+require_relative 'brainzlab/cortex'
+require_relative 'brainzlab/beacon'
+require_relative 'brainzlab/nerve'
+require_relative 'brainzlab/dendrite'
+require_relative 'brainzlab/sentinel'
+require_relative 'brainzlab/synapse'
+require_relative 'brainzlab/instrumentation'
+require_relative 'brainzlab/utilities'
+require_relative 'brainzlab/development'
+
+module BrainzLab
+  # Thread-local re-entrancy guard for instrumentation.
+  # When true, SDK operations that would make HTTP calls are skipped
+  # to prevent recursive instrumentation from blocking the host app.
+  INSTRUMENTING_KEY = :brainzlab_instrumenting
+
+  class << self
+    # Returns true when inside an instrumentation handler.
+    # Used by Recall.log, Pulse.record_metric, etc. to skip HTTP calls
+    # that would block the host app during notification callbacks.
+    def instrumenting?
+      Thread.current[INSTRUMENTING_KEY] == true
+    end
+
+    # Executes a block within the instrumentation guard.
+    # Prevents recursive/cascading SDK HTTP calls from instrumentation handlers.
+    def with_instrumentation_guard
+      return if Thread.current[INSTRUMENTING_KEY]
+
+      Thread.current[INSTRUMENTING_KEY] = true
+      begin
+        yield
+      ensure
+        Thread.current[INSTRUMENTING_KEY] = nil
+      end
+    end
+
+    def configure
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+      Recall.reset!
+      Reflex.reset!
+      Pulse.reset!
+      Flux.reset!
+      Signal.reset!
+      Vault.reset!
+      Vision.reset!
+      Cortex.reset!
+      Beacon.reset!
+      Nerve.reset!
+      Dendrite.reset!
+      Sentinel.reset!
+      Synapse.reset!
+      Development.reset!
+    end
+
+    # Context management
+    def set_user(id: nil, email: nil, name: nil, **extra)
+      Context.current.set_user(id: id, email: email, name: name, **extra)
+    end
+
+    def set_context(**data)
+      Context.current.set_context(**data)
+    end
+
+    def set_tags(**data)
+      Context.current.set_tags(**data)
+    end
+
+    def with_context(**data, &)
+      Context.current.with_context(**data, &)
+    end
+
+    def clear_context!
+      Context.clear!
+    end
+
+    # Breadcrumb helpers
+    def add_breadcrumb(message, category: 'default', level: :info, data: nil)
+      Reflex.add_breadcrumb(message, category: category, level: level, data: data)
+    end
+
+    def clear_breadcrumbs!
+      Reflex.clear_breadcrumbs!
+    end
+
+    # Create a logger that can replace Rails.logger
+    # @param broadcast_to [Logger] Optional logger to also send logs to (e.g., original Rails.logger)
+    # @return [BrainzLab::Recall::Logger]
+    def logger(broadcast_to: nil)
+      Recall::Logger.new(nil, broadcast_to: broadcast_to)
+    end
+
+    # Debug logging helper
+    def debug_log(message)
+      configuration.debug_log(message)
+    end
+
+    # Check if debug mode is enabled
+    def debug?
+      configuration.debug?
+    end
+
+    # Query events stored in development mode
+    # @param service [Symbol, nil] filter by service (:recall, :reflex, :pulse, etc.)
+    # @param event_type [String, nil] filter by event type ('log', 'error', 'trace', etc.)
+    # @param since [Time, nil] filter events after this time
+    # @param limit [Integer] max number of events to return (default: 100)
+    # @return [Array<Hash>] matching events
+    # @example
+    #   BrainzLab.development_events                              # All events
+    #   BrainzLab.development_events(service: :recall)            # Only Recall logs
+    #   BrainzLab.development_events(service: :reflex, limit: 10) # Last 10 errors
+    #   BrainzLab.development_events(since: 1.hour.ago)           # Events from last hour
+    def development_events(service: nil, event_type: nil, since: nil, limit: 100)
+      Development.events(service: service, event_type: event_type, since: since, limit: limit)
+    end
+
+    # Clear all events stored in development mode
+    def clear_development_events!
+      Development.clear!
+    end
+
+    # Get stats about stored development events
+    # @return [Hash] counts by service
+    def development_stats
+      Development.stats
+    end
+
+    # Health check - verifies connectivity to all enabled services
+    # @return [Hash] Status of each service
+    def health_check
+      results = { status: 'ok', services: {} }
+
+      # Check Recall
+      if configuration.recall_enabled
+        results[:services][:recall] = check_service_health(
+          url: configuration.recall_url,
+          name: 'Recall'
+        )
+      end
+
+      # Check Reflex
+      if configuration.reflex_enabled
+        results[:services][:reflex] = check_service_health(
+          url: configuration.reflex_url,
+          name: 'Reflex'
+        )
+      end
+
+      # Check Pulse
+      if configuration.pulse_enabled
+        results[:services][:pulse] = check_service_health(
+          url: configuration.pulse_url,
+          name: 'Pulse'
+        )
+      end
+
+      # Check Flux
+      if configuration.flux_enabled
+        results[:services][:flux] = check_service_health(
+          url: configuration.flux_url,
+          name: 'Flux'
+        )
+      end
+
+      # Check Signal
+      if configuration.signal_enabled
+        results[:services][:signal] = check_service_health(
+          url: configuration.signal_url,
+          name: 'Signal'
+        )
+      end
+
+      # Check Vault
+      if configuration.vault_enabled
+        results[:services][:vault] = check_service_health(
+          url: configuration.vault_url,
+          name: 'Vault'
+        )
+      end
+
+      # Check Vision
+      if configuration.vision_enabled
+        results[:services][:vision] = check_service_health(
+          url: configuration.vision_url,
+          name: 'Vision'
+        )
+      end
+
+      # Check Cortex
+      if configuration.cortex_enabled
+        results[:services][:cortex] = check_service_health(
+          url: configuration.cortex_url,
+          name: 'Cortex'
+        )
+      end
+
+      # Check Beacon
+      if configuration.beacon_enabled
+        results[:services][:beacon] = check_service_health(
+          url: configuration.beacon_url,
+          name: 'Beacon'
+        )
+      end
+
+      # Check Nerve
+      if configuration.nerve_enabled
+        results[:services][:nerve] = check_service_health(
+          url: configuration.nerve_url,
+          name: 'Nerve'
+        )
+      end
+
+      # Check Dendrite
+      if configuration.dendrite_enabled
+        results[:services][:dendrite] = check_service_health(
+          url: configuration.dendrite_url,
+          name: 'Dendrite'
+        )
+      end
+
+      # Check Sentinel
+      if configuration.sentinel_enabled
+        results[:services][:sentinel] = check_service_health(
+          url: configuration.sentinel_url,
+          name: 'Sentinel'
+        )
+      end
+
+      # Check Synapse
+      if configuration.synapse_enabled
+        results[:services][:synapse] = check_service_health(
+          url: configuration.synapse_url,
+          name: 'Synapse'
+        )
+      end
+
+      # Overall status
+      has_failure = results[:services].values.any? { |s| s[:status] == 'error' }
+      results[:status] = has_failure ? 'degraded' : 'ok'
+
+      results
+    end
+
+    private
+
+    def check_service_health(url:, name:)
+      require 'net/http'
+      require 'uri'
+
+      uri = URI.parse("#{url}/up")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = 5
+      http.read_timeout = 5
+
+      response = http.get(uri.request_uri)
+
+      if response.is_a?(Net::HTTPSuccess)
+        { status: 'ok', latency_ms: 0 }
+      else
+        { status: 'error', message: "HTTP #{response.code}" }
+      end
+    rescue StandardError => e
+      { status: 'error', message: e.message }
+    end
+  end
+end
+
+# Auto-load Rails integration if Rails is available
+require_relative 'brainzlab/rails/railtie' if defined?(Rails::Railtie)

data/lib/generators/brainzlab/install/install_generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Brainzlab
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates a BrainzLab initializer for your Rails application'
+
+      class_option :key, type: :string, desc: 'Your BrainzLab secret key'
+      class_option :replace_logger, type: :boolean, default: false, desc: 'Replace Rails.logger with BrainzLab logger'
+
+      def copy_initializer
+        template 'brainzlab.rb.tt', 'config/initializers/brainzlab.rb'
+      end
+
+      def show_post_install_message
+        say ''
+        say 'BrainzLab SDK installed successfully!', :green
+        say ''
+        say 'Next steps:'
+        say '  1. Set your environment variables:'
+        say '     BRAINZLAB_SECRET_KEY - Your API key from https://brainzlab.ai/dashboard'
+        say ''
+        say '     Or for auto-provisioning:'
+        say '     RECALL_MASTER_KEY - Master key for Recall auto-provisioning'
+        say '     REFLEX_MASTER_KEY - Master key for Reflex auto-provisioning'
+        say ''
+        say '  2. Start logging:'
+        say "     BrainzLab::Recall.info('Hello from BrainzLab!')"
+        say ''
+        say '  3. Capture errors (automatic with Rails, or manual):'
+        say '     BrainzLab::Reflex.capture(exception)'
+        say ''
+        if options[:replace_logger]
+          say '  Rails.logger is now connected to Recall!', :yellow
+        else
+          say '  To send all Rails logs to Recall, add to your initializer:'
+          say '     Rails.logger = BrainzLab.logger(broadcast_to: Rails.logger)'
+        end
+        say ''
+      end
+
+      private
+
+      def secret_key_value
+        if options[:key].present?
+          %("#{options[:key]}")
+        else
+          'ENV["BRAINZLAB_SECRET_KEY"]'
+        end
+      end
+
+      def app_name
+        Rails.application.class.module_parent_name.underscore
+      rescue StandardError
+        'my-app'
+      end
+    end
+  end
+end

data/lib/generators/brainzlab/install/templates/brainzlab.rb.tt

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+BrainzLab.configure do |config|
+  # Your secret key from https://brainzlab.ai/dashboard
+  # If using auto-provisioning, you can omit this and set master keys instead
+  config.secret_key = <%= secret_key_value %>
+
+  # App name for auto-provisioning (required for auto-provision)
+  config.app_name = "<%= app_name %>"
+
+  # Environment (defaults to Rails.env)
+  # config.environment = Rails.env
+
+  # Service name (defaults to app name)
+  config.service = "<%= app_name %>"
+
+  # ============================================================================
+  # Recall - Logging
+  # ============================================================================
+
+  # Enable/disable Recall logging
+  # config.recall_enabled = true
+
+  # Recall URL (defaults to https://recall.brainzlab.ai)
+  # config.recall_url = ENV.fetch("RECALL_URL", "https://recall.brainzlab.ai")
+
+  # Master key for auto-provisioning (set in environment)
+  # config.recall_master_key = ENV["RECALL_MASTER_KEY"]
+
+  # Minimum log level to send to Recall
+  # config.recall_min_level = :debug  # :debug, :info, :warn, :error, :fatal
+
+  # Buffer settings for batching logs
+  # config.recall_buffer_size = 50      # Flush after 50 logs
+  # config.recall_flush_interval = 5    # Or every 5 seconds
+
+  # ============================================================================
+  # Reflex - Error Tracking
+  # ============================================================================
+
+  # Enable/disable Reflex error tracking
+  # config.reflex_enabled = true
+
+  # Reflex URL (defaults to https://reflex.brainzlab.ai)
+  # config.reflex_url = ENV.fetch("REFLEX_URL", "https://reflex.brainzlab.ai")
+
+  # Master key for auto-provisioning (set in environment)
+  # config.reflex_master_key = ENV["REFLEX_MASTER_KEY"]
+
+  # Exceptions to exclude from Reflex error tracking
+  # config.reflex_excluded_exceptions = [
+  #   "ActionController::RoutingError",
+  #   "ActionController::InvalidAuthenticityToken",
+  #   "ActiveRecord::RecordNotFound"
+  # ]
+
+  # Sample rate for errors (1.0 = 100%, 0.5 = 50%)
+  # config.reflex_sample_rate = 1.0
+
+  # Before send hook to modify or filter errors
+  # config.reflex_before_send = ->(payload, exception) {
+  #   # Return nil to drop the error, or modify and return payload
+  #   payload
+  # }
+
+  # ============================================================================
+  # General
+  # ============================================================================
+
+  # Fields to scrub from logs and errors
+  # config.scrub_fields = %i[password password_confirmation token api_key secret credit_card]
+end
+<% if options[:replace_logger] %>
+
+# Send all Rails logs to Recall (keeps console output too)
+Rails.logger = BrainzLab.logger(broadcast_to: Rails.logger)
+<% end %>