brainzlab 0.1.1 → 0.1.2

data/lib/brainzlab/cortex.rb

@@ -0,0 +1,227 @@
+# 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)
+        result == true || result == "true"
+      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
+        if BrainzLab.configuration.cortex_cache_enabled && cache.has?(cache_key)
+          return cache.get(cache_key)
+        end
+
+        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 = {}
+        if BrainzLab::Context.current.user
+          brainzlab_context[:user] = BrainzLab::Context.current.user
+        end
+
+        # 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,232 @@
+# 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}")
+
+        if params
+          uri.query = URI.encode_www_form(params)
+        end
+
+        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["BRAINZLAB_PROJECT_ID"]
+      end
+    end
+  end
+end

data/lib/brainzlab/dendrite.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "dendrite/client"
+require_relative "dendrite/provisioner"
+
+module BrainzLab
+  module Dendrite
+    class << self
+      # Connect a Git repository for documentation
+      # @param url [String] Git repository URL
+      # @param name [String] Optional display name
+      # @param branch [String] Branch to track (default: main)
+      # @return [Hash, nil] Repository info
+      #
+      # @example
+      #   BrainzLab::Dendrite.connect(
+      #     "https://github.com/org/repo",
+      #     name: "My API",
+      #     branch: "main"
+      #   )
+      #
+      def connect(url, name: nil, branch: "main", **options)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.connect_repository(url: url, name: name, branch: branch, **options)
+      end
+
+      # Trigger documentation sync for a repository
+      # @param repo_id [String] Repository ID
+      # @return [Boolean] True if sync started
+      def sync(repo_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.dendrite_valid?
+
+        client.sync_repository(repo_id)
+      end
+
+      # Get repository info
+      # @param repo_id [String] Repository ID
+      # @return [Hash, nil] Repository details
+      def repository(repo_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.get_repository(repo_id)
+      end
+
+      # List all connected repositories
+      # @return [Array<Hash>] List of repositories
+      def repositories
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.dendrite_valid?
+
+        client.list_repositories
+      end
+
+      # Get wiki for a repository
+      # @param repo_id [String] Repository ID
+      # @return [Hash, nil] Wiki structure
+      def wiki(repo_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.get_wiki(repo_id)
+      end
+
+      # Get a specific wiki page
+      # @param repo_id [String] Repository ID
+      # @param page [String] Page slug (e.g., "models/user")
+      # @return [Hash, nil] Page content
+      def page(repo_id, page_slug)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.get_wiki_page(repo_id, page_slug)
+      end
+
+      # Semantic search across the codebase
+      # @param repo_id [String] Repository ID
+      # @param query [String] Search query
+      # @param limit [Integer] Max results (default: 10)
+      # @return [Array<Hash>] Search results
+      #
+      # @example
+      #   results = BrainzLab::Dendrite.search(repo_id, "authentication flow")
+      #
+      def search(repo_id, query, limit: 10)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.dendrite_valid?
+
+        client.search(repo_id, query, limit: limit)
+      end
+
+      # Ask a question about the codebase
+      # @param repo_id [String] Repository ID
+      # @param question [String] Question to ask
+      # @param session_id [String] Optional session for follow-up questions
+      # @return [Hash, nil] AI response with answer
+      #
+      # @example
+      #   response = BrainzLab::Dendrite.ask(repo_id, "How does the payment flow work?")
+      #   puts response[:answer]
+      #
+      def ask(repo_id, question, session_id: nil)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.ask(repo_id, question, session_id: session_id)
+      end
+
+      # Explain a file or code symbol
+      # @param repo_id [String] Repository ID
+      # @param path [String] File path
+      # @param symbol [String] Optional specific symbol (class, method)
+      # @return [Hash, nil] Explanation
+      #
+      # @example
+      #   explanation = BrainzLab::Dendrite.explain(repo_id, "app/models/user.rb", symbol: "authenticate")
+      #
+      def explain(repo_id, path, symbol: nil)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.explain(repo_id, path, symbol: symbol)
+      end
+
+      # Generate a diagram
+      # @param repo_id [String] Repository ID
+      # @param type [Symbol] Diagram type (:class, :er, :sequence, :architecture)
+      # @param scope [String] Optional scope (module, class name)
+      # @return [Hash, nil] Mermaid diagram
+      #
+      # @example
+      #   diagram = BrainzLab::Dendrite.diagram(repo_id, :er)
+      #   puts diagram[:mermaid]
+      #
+      def diagram(repo_id, type:, scope: nil)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.generate_diagram(repo_id, type: type, scope: scope)
+      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 reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.dendrite_enabled
+      end
+    end
+  end
+end