brainzlab 0.1.1 → 0.1.3

data/lib/brainzlab/cortex/client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'cgi'
+
+module BrainzLab
+  module Cortex
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.cortex_url || 'https://cortex.brainzlab.ai'
+      end
+
+      # Evaluate a single flag
+      def evaluate(flag_name, context: {})
+        response = request(
+          :post,
+          '/api/v1/evaluate',
+          body: {
+            flag: flag_name,
+            context: context
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:result]
+      rescue StandardError => e
+        log_error('evaluate', e)
+        nil
+      end
+
+      # Evaluate multiple flags at once
+      def evaluate_all(context: {})
+        response = request(
+          :post,
+          '/api/v1/evaluate/batch',
+          body: { context: context }
+        )
+
+        return {} unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:flags] || {}
+      rescue StandardError => e
+        log_error('evaluate_all', e)
+        {}
+      end
+
+      # List all flags
+      def list
+        response = request(:get, '/api/v1/flags')
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:flags] || []
+      rescue StandardError => e
+        log_error('list', e)
+        []
+      end
+
+      # Get flag details
+      def get_flag(flag_name)
+        response = request(:get, "/api/v1/flags/#{CGI.escape(flag_name.to_s)}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error('get_flag', 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 = 5
+        http.read_timeout = 10
+
+        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
+
+        # Set headers
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = 'application/json'
+
+        if use_service_key
+          request['X-Service-Key'] = @config.cortex_master_key || @config.secret_key
+        else
+          auth_key = @config.cortex_api_key || @config.secret_key
+          request['Authorization'] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+
+        # Set body
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        BrainzLab.debug_log("[Cortex::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/cortex/provisioner.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Cortex
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.cortex_auto_provision
+        return unless valid_auth?
+
+        @provisioned = true
+
+        # Try to provision with Platform project ID
+        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("[Cortex::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Cortex::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.cortex_api_key || @config.cortex_master_key || @config.secret_key
+        !key.nil? && !key.empty?
+      end
+
+      def detect_project_id
+        # Try environment variable first
+        return ENV['BRAINZLAB_PROJECT_ID'] if ENV['BRAINZLAB_PROJECT_ID']
+
+        # Could also detect from Platform API if we have a secret key
+        nil
+      end
+    end
+  end
+end

data/lib/brainzlab/cortex.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative 'cortex/client'
+require_relative 'cortex/cache'
+require_relative 'cortex/provisioner'
+
+module BrainzLab
+  module Cortex
+    class << self
+      # Check if a feature flag is enabled
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context (user, attributes, etc.)
+      # @return [Boolean] True if the flag is enabled
+      #
+      # @example
+      #   if BrainzLab::Cortex.enabled?(:new_checkout, user: current_user)
+      #     render_new_checkout
+      #   end
+      #
+      def enabled?(flag_name, **context)
+        result = get(flag_name, **context)
+        [true, 'true'].include?(result)
+      end
+
+      # Check if a feature flag is disabled
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @return [Boolean] True if the flag is disabled
+      def disabled?(flag_name, **context)
+        !enabled?(flag_name, **context)
+      end
+
+      # Get the value of a feature flag
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @param default [Object] Default value if flag not found
+      # @return [Object] The flag value
+      #
+      # @example
+      #   limit = BrainzLab::Cortex.get(:rate_limit, user: current_user, default: 100)
+      #
+      def get(flag_name, default: nil, **context)
+        return default unless module_enabled?
+
+        ensure_provisioned!
+        return default unless BrainzLab.configuration.cortex_valid?
+
+        flag_key = flag_name.to_s
+        merged_context = merge_context(context)
+        cache_key = build_cache_key(flag_key, merged_context)
+
+        # Check cache first
+        return cache.get(cache_key) if BrainzLab.configuration.cortex_cache_enabled && cache.has?(cache_key)
+
+        result = client.evaluate(flag_key, context: merged_context)
+
+        if result.nil?
+          default
+        else
+          cache.set(cache_key, result) if BrainzLab.configuration.cortex_cache_enabled
+          result
+        end
+      end
+
+      # Get the variant for an A/B test flag
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @param default [String] Default variant if flag not found
+      # @return [String, nil] The variant name
+      #
+      # @example
+      #   variant = BrainzLab::Cortex.variant(:checkout_experiment, user: current_user)
+      #   case variant
+      #   when "control" then render_control
+      #   when "treatment_a" then render_treatment_a
+      #   when "treatment_b" then render_treatment_b
+      #   end
+      #
+      def variant(flag_name, default: nil, **context)
+        result = get(flag_name, **context)
+        result.is_a?(String) ? result : default
+      end
+
+      # Get all flags for a context
+      # @param context [Hash] Evaluation context
+      # @return [Hash] All flag values
+      #
+      # @example
+      #   flags = BrainzLab::Cortex.all(user: current_user)
+      #   flags[:new_checkout]  # => true
+      #   flags[:rate_limit]    # => 200
+      #
+      def all(**context)
+        return {} unless module_enabled?
+
+        ensure_provisioned!
+        return {} unless BrainzLab.configuration.cortex_valid?
+
+        merged_context = merge_context(context)
+        client.evaluate_all(context: merged_context)
+      end
+
+      # List all flag definitions
+      # @return [Array<Hash>] List of flag metadata
+      def list_flags
+        return [] unless module_enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.cortex_valid?
+
+        client.list
+      end
+
+      # Get a flag's configuration
+      # @param flag_name [String, Symbol] The flag name
+      # @return [Hash, nil] Flag configuration
+      def flag_config(flag_name)
+        return nil unless module_enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.cortex_valid?
+
+        client.get_flag(flag_name.to_s)
+      end
+
+      # Clear the flag cache
+      def clear_cache!
+        cache.clear!
+      end
+
+      # === Context Helpers ===
+
+      # Set default context for all evaluations in current request
+      # @param context [Hash] Context to merge
+      def set_context(**context)
+        Thread.current[:cortex_context] = (Thread.current[:cortex_context] || {}).merge(context)
+      end
+
+      # Clear the current context
+      def clear_context!
+        Thread.current[:cortex_context] = nil
+      end
+
+      # Evaluate flags with a temporary context
+      # @param context [Hash] Temporary context
+      def with_context(**context)
+        previous = Thread.current[:cortex_context]
+        Thread.current[:cortex_context] = (previous || {}).merge(context)
+        yield
+      ensure
+        Thread.current[:cortex_context] = previous
+      end
+
+      # === INTERNAL ===
+
+      def ensure_provisioned!
+        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 cache
+        @cache ||= Cache.new(BrainzLab.configuration.cortex_cache_ttl)
+      end
+
+      def reset!
+        @client = nil
+        @provisioner = nil
+        @cache = nil
+        @provisioned = false
+        Thread.current[:cortex_context] = nil
+      end
+
+      private
+
+      def module_enabled?
+        BrainzLab.configuration.cortex_enabled
+      end
+
+      def merge_context(context)
+        default_context = BrainzLab.configuration.cortex_default_context || {}
+        thread_context = Thread.current[:cortex_context] || {}
+
+        # Also include user from BrainzLab context if available
+        brainzlab_context = {}
+        brainzlab_context[:user] = BrainzLab::Context.current.user if BrainzLab::Context.current.user
+
+        # Normalize user context
+        merged = default_context.merge(brainzlab_context).merge(thread_context).merge(context)
+
+        # Convert user object to hash if needed
+        if merged[:user].respond_to?(:id)
+          merged[:user] = {
+            id: merged[:user].id.to_s,
+            email: merged[:user].try(:email),
+            name: merged[:user].try(:name)
+          }.compact
+        end
+
+        merged
+      end
+
+      def build_cache_key(flag_name, context)
+        # Include relevant context in cache key
+        user_id = context.dig(:user, :id) || context[:user_id]
+        env = BrainzLab.configuration.environment
+
+        parts = [env, flag_name]
+        parts << "u:#{user_id}" if user_id
+        parts.join(':')
+      end
+    end
+  end
+end

data/lib/brainzlab/dendrite/client.rb

@@ -0,0 +1,230 @@
+# 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)
+        BrainzLab.debug_log("[Dendrite::Client] #{operation} failed: #{error.message}")
+      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