brainzlab 0.1.2 → 0.1.3

data/lib/brainzlab/dendrite/client.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
-require "cgi"
+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"
+        @base_url = config.dendrite_url || 'https://dendrite.brainzlab.ai'
       end
 
       # Connect a repository
-      def connect_repository(url:, name: nil, branch: "main", **options)
+      def connect_repository(url:, name: nil, branch: 'main', **options)
         response = request(
           :post,
-          "/api/v1/repositories",
+          '/api/v1/repositories',
           body: {
             url: url,
             name: name,
@@ -30,7 +30,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("connect_repository", e)
+        log_error('connect_repository', e)
         nil
       end
 
@@ -39,7 +39,7 @@ module BrainzLab
         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)
+        log_error('sync_repository', e)
         false
       end
 
@@ -51,20 +51,20 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_repository", e)
+        log_error('get_repository', e)
         nil
       end
 
       # List repositories
       def list_repositories
-        response = request(:get, "/api/v1/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)
+        log_error('list_repositories', e)
         []
       end
 
@@ -76,7 +76,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_wiki", e)
+        log_error('get_wiki', e)
         nil
       end
 
@@ -88,7 +88,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_wiki_page", e)
+        log_error('get_wiki_page', e)
         nil
       end
 
@@ -96,7 +96,7 @@ module BrainzLab
       def search(repo_id, query, limit: 10)
         response = request(
           :get,
-          "/api/v1/search",
+          '/api/v1/search',
           params: { repo_id: repo_id, q: query, limit: limit }
         )
 
@@ -105,7 +105,7 @@ module BrainzLab
         data = JSON.parse(response.body, symbolize_names: true)
         data[:results] || []
       rescue StandardError => e
-        log_error("search", e)
+        log_error('search', e)
         []
       end
 
@@ -113,7 +113,7 @@ module BrainzLab
       def ask(repo_id, question, session_id: nil)
         response = request(
           :post,
-          "/api/v1/chat",
+          '/api/v1/chat',
           body: {
             repo_id: repo_id,
             question: question,
@@ -125,7 +125,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("ask", e)
+        log_error('ask', e)
         nil
       end
 
@@ -133,7 +133,7 @@ module BrainzLab
       def explain(repo_id, path, symbol: nil)
         response = request(
           :post,
-          "/api/v1/explain",
+          '/api/v1/explain',
           body: {
             repo_id: repo_id,
             path: path,
@@ -145,7 +145,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("explain", e)
+        log_error('explain', e)
         nil
       end
 
@@ -153,10 +153,10 @@ module BrainzLab
       def generate_diagram(repo_id, type:, scope: nil)
         response = request(
           :post,
-          "/api/v1/diagrams",
+          '/api/v1/diagrams',
           body: {
             repo_id: repo_id,
-            type: type,  # class, er, sequence, architecture
+            type: type, # class, er, sequence, architecture
             scope: scope
           }
         )
@@ -165,21 +165,21 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("generate_diagram", e)
+        log_error('generate_diagram', e)
         nil
       end
 
       def provision(project_id:, app_name:)
         response = request(
           :post,
-          "/api/v1/projects/provision",
+          '/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)
+        log_error('provision', e)
         false
       end
 
@@ -188,34 +188,32 @@ module BrainzLab
       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
+        uri.query = URI.encode_www_form(params) if params
 
         http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
+        http.use_ssl = uri.scheme == 'https'
         http.open_timeout = 10
-        http.read_timeout = 60  # Longer timeout for AI operations
+        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"
+                  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
+          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
+          request['Authorization'] = "Bearer #{auth_key}" if auth_key
         end
 
         headers.each { |k, v| request[k] = v }

data/lib/brainzlab/dendrite/provisioner.rb

@@ -37,7 +37,7 @@ module BrainzLab
       end
 
       def detect_project_id
-        ENV["BRAINZLAB_PROJECT_ID"]
+        ENV.fetch('BRAINZLAB_PROJECT_ID', nil)
       end
     end
   end

data/lib/brainzlab/dendrite.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "dendrite/client"
-require_relative "dendrite/provisioner"
+require_relative 'dendrite/client'
+require_relative 'dendrite/provisioner'
 
 module BrainzLab
   module Dendrite
@@ -19,13 +19,13 @@ module BrainzLab
       #     branch: "main"
       #   )
       #
-      def connect(url, name: nil, branch: "main", **options)
+      def connect(url, name: nil, branch: 'main', **)
         return nil unless enabled?
 
         ensure_provisioned!
         return nil unless BrainzLab.configuration.dendrite_valid?
 
-        client.connect_repository(url: url, name: name, branch: branch, **options)
+        client.connect_repository(url: url, name: name, branch: branch, **)
       end
 
       # Trigger documentation sync for a repository

data/lib/brainzlab/devtools/data/collector.rb

@@ -50,7 +50,7 @@ module BrainzLab
               logs: data[:logs] || [],
               memory: build_memory_data(data),
               user: context&.user,
-              breadcrumbs: context&.breadcrumbs&.to_a || []
+              breadcrumbs: context&.breadcrumbs.to_a
             }
           end
 
@@ -98,15 +98,15 @@ module BrainzLab
 
           def build_request_data(data, context)
             env = data[:env] || {}
-            request = env["action_dispatch.request"] || (defined?(ActionDispatch::Request) ? ActionDispatch::Request.new(env) : nil)
+            env['action_dispatch.request'] || (defined?(ActionDispatch::Request) ? ActionDispatch::Request.new(env) : nil)
 
             {
-              method: context&.request_method || env["REQUEST_METHOD"],
-              path: context&.request_path || env["PATH_INFO"],
-              url: context&.request_url || env["REQUEST_URI"],
+              method: context&.request_method || env['REQUEST_METHOD'],
+              path: context&.request_path || env['PATH_INFO'],
+              url: context&.request_url || env['REQUEST_URI'],
               params: context&.request_params || {},
               headers: extract_headers(env),
-              request_id: context&.request_id || env["action_dispatch.request_id"]
+              request_id: context&.request_id || env['action_dispatch.request_id']
             }
           end
 
@@ -149,8 +149,8 @@ module BrainzLab
           def extract_headers(env)
             headers = {}
             env.each do |key, value|
-              if key.start_with?("HTTP_")
-                header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+              if key.start_with?('HTTP_')
+                header_name = key.sub('HTTP_', '').split('_').map(&:capitalize).join('-')
                 headers[header_name] = value
               end
             end
@@ -160,23 +160,23 @@ module BrainzLab
           def subscribe_to_events
             return unless defined?(ActiveSupport::Notifications)
 
-            @sql_subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+            @sql_subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
               event = ActiveSupport::Notifications::Event.new(*args)
-              next if event.payload[:name] == "SCHEMA"
-              next if event.payload[:sql]&.start_with?("PRAGMA")
+              next if event.payload[:name] == 'SCHEMA'
+              next if event.payload[:sql]&.start_with?('PRAGMA')
 
               add_sql_query(
                 name: event.payload[:name],
                 duration: event.duration,
                 sql: event.payload[:sql],
-                cached: event.payload[:cached] || event.payload[:name] == "CACHE",
+                cached: event.payload[:cached] || event.payload[:name] == 'CACHE',
                 source: extract_source(caller)
               )
             end
 
             @view_subscriber = ActiveSupport::Notifications.subscribe(/render_.+\.action_view/) do |*args|
               event = ActiveSupport::Notifications::Event.new(*args)
-              type = event.name.include?("partial") ? :partial : :template
+              type = event.name.include?('partial') ? :partial : :template
 
               add_view(
                 type: type,
@@ -214,11 +214,11 @@ module BrainzLab
           def normalize_sql(sql)
             return nil unless sql
 
-            sql.gsub(/\b\d+\b/, "?")
-               .gsub(/'[^']*'/, "?")
-               .gsub(/\$\d+/, "?")
-               .gsub(%r{/\*.*?\*/}, "")
-               .gsub(/\s+/, " ")
+            sql.gsub(/\b\d+\b/, '?')
+               .gsub(/'[^']*'/, '?')
+               .gsub(/\$\d+/, '?')
+               .gsub(%r{/\*.*?\*/}, '')
+               .gsub(/\s+/, ' ')
                .strip
           end
 
@@ -230,11 +230,11 @@ module BrainzLab
 
           def extract_source(backtrace)
             backtrace.each do |line|
-              next if line.include?("/brainzlab")
-              next if line.include?("/gems/")
-              next if line.include?("/ruby/")
+              next if line.include?('/brainzlab')
+              next if line.include?('/gems/')
+              next if line.include?('/ruby/')
 
-              if line.include?("/app/")
+              if line.include?('/app/')
                 match = line.match(%r{(app/[^:]+:\d+)})
                 return match[1] if match
               end

data/lib/brainzlab/devtools/middleware/asset_server.rb

@@ -5,11 +5,11 @@ module BrainzLab
     module Middleware
       class AssetServer
         MIME_TYPES = {
-          ".css" => "text/css; charset=utf-8",
-          ".js" => "application/javascript; charset=utf-8",
-          ".svg" => "image/svg+xml",
-          ".png" => "image/png",
-          ".woff2" => "font/woff2"
+          '.css' => 'text/css; charset=utf-8',
+          '.js' => 'application/javascript; charset=utf-8',
+          '.svg' => 'image/svg+xml',
+          '.png' => 'image/png',
+          '.woff2' => 'font/woff2'
         }.freeze
 
         def initialize(app)
@@ -19,11 +19,11 @@ module BrainzLab
         def call(env)
           return @app.call(env) unless DevTools.enabled?
 
-          path = env["PATH_INFO"]
+          path = env['PATH_INFO']
           asset_prefix = DevTools.asset_path
 
           if path.start_with?("#{asset_prefix}/")
-            serve_asset(path.sub("#{asset_prefix}/", ""))
+            serve_asset(path.sub("#{asset_prefix}/", ''))
           else
             @app.call(env)
           end
@@ -33,29 +33,29 @@ module BrainzLab
 
         def serve_asset(relative_path)
           # Prevent directory traversal
-          return not_found if relative_path.include?("..")
+          return not_found if relative_path.include?('..')
 
           file_path = File.join(DevTools::ASSETS_PATH, relative_path)
           return not_found unless File.exist?(file_path)
 
           ext = File.extname(relative_path)
-          content_type = MIME_TYPES[ext] || "application/octet-stream"
+          content_type = MIME_TYPES[ext] || 'application/octet-stream'
           content = File.read(file_path)
 
           [
             200,
             {
-              "Content-Type" => content_type,
-              "Content-Length" => content.bytesize.to_s,
-              "Cache-Control" => "public, max-age=31536000",
-              "X-Content-Type-Options" => "nosniff"
+              'Content-Type' => content_type,
+              'Content-Length' => content.bytesize.to_s,
+              'Cache-Control' => 'public, max-age=31536000',
+              'X-Content-Type-Options' => 'nosniff'
             },
             [content]
           ]
         end
 
         def not_found
-          [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
+          [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
         end
       end
     end

data/lib/brainzlab/devtools/middleware/database_handler.rb

@@ -4,7 +4,7 @@ module BrainzLab
   module DevTools
     module Middleware
       class DatabaseHandler
-        ENDPOINT = "/_brainzlab/devtools/database"
+        ENDPOINT = '/_brainzlab/devtools/database'
 
         def initialize(app)
           @app = app
@@ -22,67 +22,65 @@ module BrainzLab
           return false unless DevTools.enabled?
           return false unless DevTools.allowed_environment?
           return false unless DevTools.allowed_ip?(extract_ip(env))
-          return false unless env["PATH_INFO"] == ENDPOINT
-          return false unless env["REQUEST_METHOD"] == "POST"
+          return false unless env['PATH_INFO'] == ENDPOINT
+          return false unless env['REQUEST_METHOD'] == 'POST'
 
           true
         end
 
         def extract_ip(env)
-          forwarded = env["HTTP_X_FORWARDED_FOR"]
-          return forwarded.split(",").first.strip if forwarded
+          forwarded = env['HTTP_X_FORWARDED_FOR']
+          return forwarded.split(',').first.strip if forwarded
 
-          env["REMOTE_ADDR"]
+          env['REMOTE_ADDR']
         end
 
         def handle_database_request(env)
-          begin
-            body = env["rack.input"].read
-            env["rack.input"].rewind
-            params = JSON.parse(body)
-            action = params["action"]
-
-            result = case action
-            when "migrate"
-              run_migrations
-            when "status"
-              migration_status
-            when "create"
-              create_database
-            when "rollback"
-              rollback_migration
-            else
-              { success: false, output: "Unknown action: #{action}" }
-            end
-
-            json_response(result)
-          rescue => e
-            json_response({ success: false, output: "Error: #{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" })
-          end
+          body = env['rack.input'].read
+          env['rack.input'].rewind
+          params = JSON.parse(body)
+          action = params['action']
+
+          result = case action
+                   when 'migrate'
+                     run_migrations
+                   when 'status'
+                     migration_status
+                   when 'create'
+                     create_database
+                   when 'rollback'
+                     rollback_migration
+                   else
+                     { success: false, output: "Unknown action: #{action}" }
+                   end
+
+          json_response(result)
+        rescue StandardError => e
+          json_response({ success: false, output: "Error: #{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" })
         end
 
         def run_migrations
-          return not_available("Rails") unless defined?(Rails)
+          return not_available('Rails') unless defined?(::Rails)
 
           output = capture_output do
             ActiveRecord::MigrationContext.new(
-              Rails.root.join("db/migrate"),
+              ::Rails.root.join('db/migrate'),
               ActiveRecord::SchemaMigration
             ).migrate
           end
 
-          { success: true, output: output.presence || "All migrations completed successfully!" }
-        rescue => e
+          { success: true, output: output.presence || 'All migrations completed successfully!' }
+        rescue StandardError => e
           { success: false, output: "Migration failed:\n#{e.message}\n\n#{e.backtrace&.first(10)&.join("\n")}" }
         end
 
         def migration_status
-          return not_available("Rails") unless defined?(Rails)
+          return not_available('Rails') unless defined?(::Rails)
 
           output = StringIO.new
 
           context = ActiveRecord::MigrationContext.new(
-            Rails.root.join("db/migrate"),
+            ::Rails.root.join('db/migrate'),
             ActiveRecord::SchemaMigration
           )
 
@@ -90,55 +88,54 @@ module BrainzLab
           migrations = context.migrations
 
           output.puts "database: #{ActiveRecord::Base.connection_db_config.database}"
-          output.puts ""
-          output.puts " Status   Migration ID    Migration Name"
-          output.puts "-" * 60
+          output.puts ''
+          output.puts ' Status   Migration ID    Migration Name'
+          output.puts '-' * 60
 
           migrations.each do |migration|
-            status = migrated.include?(migration.version) ? "   up" : " down"
+            status = migrated.include?(migration.version) ? '   up' : ' down'
             output.puts " #{status}     #{migration.version}  #{migration.name}"
           end
 
           pending = migrations.reject { |m| migrated.include?(m.version) }
+          output.puts ''
           if pending.any?
-            output.puts ""
             output.puts "#{pending.count} pending migration(s)"
           else
-            output.puts ""
-            output.puts "All migrations are up to date!"
+            output.puts 'All migrations are up to date!'
           end
 
           { success: true, output: output.string }
-        rescue => e
+        rescue StandardError => e
           { success: false, output: "Failed to check status:\n#{e.message}" }
         end
 
         def create_database
-          return not_available("Rails") unless defined?(Rails)
+          return not_available('Rails') unless defined?(::Rails)
 
           output = capture_output do
             ActiveRecord::Tasks::DatabaseTasks.create_current
           end
 
-          { success: true, output: output.presence || "Database created successfully!" }
+          { success: true, output: output.presence || 'Database created successfully!' }
         rescue ActiveRecord::DatabaseAlreadyExists
-          { success: true, output: "Database already exists." }
-        rescue => e
+          { success: true, output: 'Database already exists.' }
+        rescue StandardError => e
           { success: false, output: "Failed to create database:\n#{e.message}" }
         end
 
         def rollback_migration
-          return not_available("Rails") unless defined?(Rails)
+          return not_available('Rails') unless defined?(::Rails)
 
           output = capture_output do
             ActiveRecord::MigrationContext.new(
-              Rails.root.join("db/migrate"),
+              ::Rails.root.join('db/migrate'),
               ActiveRecord::SchemaMigration
             ).rollback
           end
 
-          { success: true, output: output.presence || "Rollback completed!" }
-        rescue => e
+          { success: true, output: output.presence || 'Rollback completed!' }
+        rescue StandardError => e
           { success: false, output: "Rollback failed:\n#{e.message}" }
         end
 
@@ -166,10 +163,10 @@ module BrainzLab
           [
             200,
             {
-              "Content-Type" => "application/json; charset=utf-8",
-              "Content-Length" => body.bytesize.to_s,
-              "Cache-Control" => "no-store",
-              "X-Content-Type-Options" => "nosniff"
+              'Content-Type' => 'application/json; charset=utf-8',
+              'Content-Length' => body.bytesize.to_s,
+              'Cache-Control' => 'no-store',
+              'X-Content-Type-Options' => 'nosniff'
             },
             [body]
           ]