fluyenta-ruby 0.1.14

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', **)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.dendrite_valid?
+
+        client.connect_repository(url: url, name: name, branch: branch, **)
+      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

data/lib/brainzlab/development/logger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module BrainzLab
+  module Development
+    # Pretty-prints development mode events to stdout
+    class Logger
+      # ANSI color codes
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        dim: "\e[2m",
+        # Services
+        recall: "\e[36m",     # Cyan
+        reflex: "\e[31m",     # Red
+        pulse: "\e[33m",      # Yellow
+        flux: "\e[35m",       # Magenta
+        signal: "\e[32m",     # Green
+        vault: "\e[34m",      # Blue
+        vision: "\e[95m",     # Light magenta
+        cortex: "\e[96m",     # Light cyan
+        beacon: "\e[92m",     # Light green
+        nerve: "\e[93m",      # Light yellow
+        dendrite: "\e[94m",   # Light blue
+        sentinel: "\e[91m",   # Light red
+        synapse: "\e[97m",    # White
+        # Log levels
+        debug: "\e[37m",      # Gray
+        info: "\e[32m",       # Green
+        warn: "\e[33m",       # Yellow
+        error: "\e[31m",      # Red
+        fatal: "\e[35m"       # Magenta
+      }.freeze
+
+      def initialize(output: $stdout, colors: nil)
+        @output = output
+        @colors = colors.nil? ? tty? : colors
+      end
+
+      # Log an event to stdout in a readable format
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event
+      # @param payload [Hash] event data
+      def log(service:, event_type:, payload:)
+        timestamp = Time.now.strftime('%H:%M:%S.%L')
+        service_color = COLORS[service] || COLORS[:reset]
+
+        # Build the log line
+        parts = []
+        parts << colorize("[#{timestamp}]", :dim)
+        parts << colorize("[#{service.to_s.upcase}]", service_color, bold: true)
+        parts << colorize(event_type, :bold)
+
+        # Add message or name depending on event type
+        message = extract_message(payload, event_type)
+        parts << message if message
+
+        # Print the main line
+        @output.puts parts.join(' ')
+
+        # Print additional details indented
+        print_details(payload, event_type)
+      end
+
+      private
+
+      def tty?
+        @output.respond_to?(:tty?) && @output.tty?
+      end
+
+      def colorize(text, color, bold: false)
+        return text unless @colors
+
+        color_code = color.is_a?(Symbol) ? COLORS[color] : color
+        prefix = bold ? "#{COLORS[:bold]}#{color_code}" : color_code.to_s
+        "#{prefix}#{text}#{COLORS[:reset]}"
+      end
+
+      def extract_message(payload, event_type)
+        case event_type
+        when 'log'
+          level = payload[:level]&.to_sym
+          level_color = COLORS[level] || COLORS[:info]
+          msg = "#{colorize("[#{level&.upcase}]", level_color)} #{payload[:message]}"
+          msg
+        when 'error'
+          "#{payload[:error_class]}: #{payload[:message]}"
+        when 'trace'
+          duration = payload[:duration_ms] ? "(#{payload[:duration_ms]}ms)" : ''
+          "#{payload[:name]} #{duration}"
+        when 'metric'
+          "#{payload[:name]} = #{payload[:value]}"
+        when 'span'
+          duration = payload[:duration_ms] ? "(#{payload[:duration_ms]}ms)" : ''
+          "#{payload[:name]} #{duration}"
+        else
+          payload[:message] || payload[:name]
+        end
+      end
+
+      def print_details(payload, event_type)
+        details = extract_details(payload, event_type)
+        return if details.empty?
+
+        details.each do |key, value|
+          formatted_value = format_value(value)
+          @output.puts "  #{colorize(key.to_s, :dim)}: #{formatted_value}"
+        end
+      end
+
+      def extract_details(payload, event_type)
+        # Fields to exclude from details (already shown in main line)
+        excluded = %i[timestamp message level name kind]
+
+        case event_type
+        when 'log'
+          payload.except(*excluded, :environment, :service, :host)
+        when 'error'
+          payload.slice(:error_class, :environment, :request_id, :user, :tags).compact
+        when 'trace'
+          payload.slice(:request_method, :request_path, :status, :db_ms, :view_ms, :spans).compact
+        when 'metric'
+          payload.slice(:kind, :tags).compact
+        else
+          payload.except(*excluded)
+        end
+      end
+
+      def format_value(value)
+        case value
+        when Hash
+          if value.size <= 3
+            value.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
+          else
+            "\n    #{JSON.pretty_generate(value).gsub("\n", "\n    ")}"
+          end
+        when Array
+          if value.size <= 3 && value.all? { |v| v.is_a?(String) || v.is_a?(Numeric) }
+            value.inspect
+          else
+            "\n    #{JSON.pretty_generate(value).gsub("\n", "\n    ")}"
+          end
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/development/store.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+require 'json'
+require 'fileutils'
+
+module BrainzLab
+  module Development
+    # SQLite-backed store for development mode events
+    class Store
+      DEFAULT_PATH = 'tmp/brainzlab.sqlite3'
+
+      def initialize(config)
+        @config = config
+        @db_path = config.development_db_path || DEFAULT_PATH
+        @db = nil
+        ensure_database!
+      end
+
+      # Insert an event into the store
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event
+      # @param payload [Hash] event data
+      def insert(service:, event_type:, payload:)
+        db.execute(
+          'INSERT INTO events (service, event_type, payload, created_at) VALUES (?, ?, ?, ?)',
+          [service.to_s, event_type.to_s, JSON.generate(payload), Time.now.utc.iso8601(3)]
+        )
+      end
+
+      # Query events from the store
+      # @param service [Symbol, nil] filter by service
+      # @param event_type [String, nil] filter by event type
+      # @param since [Time, nil] filter events after this time
+      # @param limit [Integer] max number of events to return
+      # @return [Array<Hash>] matching events
+      def query(service: nil, event_type: nil, since: nil, limit: 100)
+        conditions = []
+        params = []
+
+        if service
+          conditions << 'service = ?'
+          params << service.to_s
+        end
+
+        if event_type
+          conditions << 'event_type = ?'
+          params << event_type.to_s
+        end
+
+        if since
+          conditions << 'created_at >= ?'
+          params << since.utc.iso8601(3)
+        end
+
+        where_clause = conditions.empty? ? '' : "WHERE #{conditions.join(' AND ')}"
+        params << limit
+
+        sql = "SELECT id, service, event_type, payload, created_at FROM events #{where_clause} ORDER BY created_at DESC LIMIT ?"
+
+        db.execute(sql, params).map do |row|
+          {
+            id: row[0],
+            service: row[1].to_sym,
+            event_type: row[2],
+            payload: JSON.parse(row[3], symbolize_names: true),
+            created_at: Time.parse(row[4])
+          }
+        end
+      end
+
+      # Get event counts by service
+      def stats
+        results = db.execute('SELECT service, COUNT(*) as count FROM events GROUP BY service')
+        results.to_h { |row| [row[0].to_sym, row[1]] }
+      end
+
+      # Clear all events
+      def clear!
+        db.execute('DELETE FROM events')
+      end
+
+      # Close the database connection
+      def close
+        @db&.close
+        @db = nil
+      end
+
+      private
+
+      def db
+        @db ||= begin
+          SQLite3::Database.new(@db_path).tap do |database|
+            database.results_as_hash = false
+          end
+        end
+      end
+
+      def ensure_database!
+        # Ensure the directory exists
+        FileUtils.mkdir_p(File.dirname(@db_path))
+
+        # Create the events table if it doesn't exist
+        db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            service TEXT NOT NULL,
+            event_type TEXT NOT NULL,
+            payload TEXT NOT NULL,
+            created_at TEXT NOT NULL
+          )
+        SQL
+
+        # Create indexes for common queries
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_service ON events(service)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type)')
+        db.execute('CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)')
+      end
+    end
+  end
+end

data/lib/brainzlab/development.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'development/store'
+require_relative 'development/logger'
+
+module BrainzLab
+  # Development mode support for offline SDK usage
+  # Logs all events to stdout and stores them locally in SQLite
+  module Development
+    class << self
+      # Check if development mode is enabled
+      def enabled?
+        BrainzLab.configuration.mode == :development
+      end
+
+      # Get the store instance
+      def store
+        @store ||= Store.new(BrainzLab.configuration)
+      end
+
+      # Get the development logger
+      def logger
+        @logger ||= Logger.new(output: BrainzLab.configuration.development_log_output || $stdout)
+      end
+
+      # Record an event from any service
+      # @param service [Symbol] :recall, :reflex, :pulse, etc.
+      # @param event_type [String] type of event (log, error, trace, metric, etc.)
+      # @param payload [Hash] event data
+      def record(service:, event_type:, payload:)
+        return unless enabled?
+
+        # Log to stdout
+        logger.log(service: service, event_type: event_type, payload: payload)
+
+        # Store in SQLite
+        store.insert(service: service, event_type: event_type, payload: payload)
+      end
+
+      # Query stored events
+      # @param service [Symbol, nil] filter by service
+      # @param event_type [String, nil] filter by event type
+      # @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
+      def events(service: nil, event_type: nil, since: nil, limit: 100)
+        return [] unless enabled?
+
+        store.query(service: service, event_type: event_type, since: since, limit: limit)
+      end
+
+      # Clear all stored events
+      def clear!
+        store.clear! if enabled?
+      end
+
+      # Reset the development module (for testing)
+      def reset!
+        @store&.close
+        @store = nil
+        @logger = nil
+      end
+
+      # Get event counts by service
+      def stats
+        return {} unless enabled?
+
+        store.stats
+      end
+    end
+  end
+end