fluyenta-ruby 0.1.14

data/lib/brainzlab/synapse.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require_relative 'synapse/client'
+require_relative 'synapse/provisioner'
+
+module BrainzLab
+  module Synapse
+    class << self
+      # List all projects
+      # @param status [String] Filter by status (running, stopped, deploying)
+      # @return [Array<Hash>] List of projects
+      #
+      # @example
+      #   projects = BrainzLab::Synapse.projects(status: "running")
+      #
+      def projects(status: nil, page: 1, per_page: 20)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.synapse_valid?
+
+        client.list_projects(status: status, page: page, per_page: per_page)
+      end
+
+      # Get project details
+      # @param project_id [String] Project ID
+      # @return [Hash, nil] Project details
+      def project(project_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.get_project(project_id)
+      end
+
+      # Create a new project
+      # @param name [String] Project name
+      # @param repos [Array<Hash>] Repository configurations
+      # @param description [String] Project description
+      # @return [Hash, nil] Created project
+      #
+      # @example
+      #   project = BrainzLab::Synapse.create_project(
+      #     name: "My App",
+      #     repos: [
+      #       { url: "https://github.com/org/api", type: "rails" },
+      #       { url: "https://github.com/org/frontend", type: "react" }
+      #     ]
+      #   )
+      #
+      def create_project(name:, repos: [], description: nil, **)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.create_project(name: name, repos: repos, description: description, **)
+      end
+
+      # Start project containers
+      # @param project_id [String] Project ID
+      # @return [Boolean] True if started
+      def up(project_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.synapse_valid?
+
+        client.start_project(project_id)
+      end
+
+      # Stop project containers
+      # @param project_id [String] Project ID
+      # @return [Boolean] True if stopped
+      def down(project_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.synapse_valid?
+
+        client.stop_project(project_id)
+      end
+
+      # Restart project containers
+      # @param project_id [String] Project ID
+      # @return [Boolean] True if restarted
+      def restart(project_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.synapse_valid?
+
+        client.restart_project(project_id)
+      end
+
+      # Deploy project to environment
+      # @param project_id [String] Project ID
+      # @param environment [Symbol] Target environment (:staging, :production)
+      # @param options [Hash] Deployment options
+      # @return [Hash, nil] Deployment info
+      #
+      # @example
+      #   deployment = BrainzLab::Synapse.deploy(project_id, environment: :staging)
+      #
+      def deploy(project_id, environment:, **options)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.deploy(project_id, environment: environment, options: options)
+      end
+
+      # Get deployment status
+      # @param deployment_id [String] Deployment ID
+      # @return [Hash, nil] Deployment details
+      def deployment(deployment_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.get_deployment(deployment_id)
+      end
+
+      # Create an AI development task
+      # @param project_id [String] Project ID
+      # @param description [String] Task description in natural language
+      # @param type [Symbol] Task type (:feature, :bugfix, :refactor, :test)
+      # @param priority [Symbol] Priority (:low, :medium, :high, :urgent)
+      # @return [Hash, nil] Created task
+      #
+      # @example
+      #   task = BrainzLab::Synapse.task(
+      #     project_id: project_id,
+      #     description: "Add user authentication with OAuth",
+      #     type: :feature,
+      #     priority: :high
+      #   )
+      #
+      def task(project_id:, description:, type: nil, priority: nil, **)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.create_task(
+          project_id: project_id,
+          description: description,
+          type: type,
+          priority: priority,
+          **
+        )
+      end
+
+      # Get task details
+      # @param task_id [String] Task ID
+      # @return [Hash, nil] Task details
+      def get_task(task_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.get_task(task_id)
+      end
+
+      # Get task status and progress
+      # @param task_id [String] Task ID
+      # @return [Hash, nil] Task status with progress
+      def task_status(task_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.get_task_status(task_id)
+      end
+
+      # List tasks
+      # @param project_id [String] Optional filter by project
+      # @param status [String] Filter by status (pending, running, completed, failed)
+      # @return [Array<Hash>] List of tasks
+      def tasks(project_id: nil, status: nil, page: 1, per_page: 20)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.synapse_valid?
+
+        client.list_tasks(project_id: project_id, status: status, page: page, per_page: per_page)
+      end
+
+      # Cancel a running task
+      # @param task_id [String] Task ID
+      # @return [Boolean] True if cancelled
+      def cancel_task(task_id)
+        return false unless enabled?
+
+        ensure_provisioned!
+        return false unless BrainzLab.configuration.synapse_valid?
+
+        client.cancel_task(task_id)
+      end
+
+      # Get container logs
+      # @param project_id [String] Project ID
+      # @param container [String] Optional container name
+      # @param lines [Integer] Number of lines (default: 100)
+      # @param since [String] Start time (ISO8601)
+      # @return [Hash, nil] Log data
+      def logs(project_id, container: nil, lines: 100, since: nil)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.get_logs(project_id, container: container, lines: lines, since: since)
+      end
+
+      # Execute command in container
+      # @param project_id [String] Project ID
+      # @param command [String] Command to execute
+      # @param container [String] Optional container name
+      # @param timeout [Integer] Timeout in seconds
+      # @return [Hash, nil] Command output
+      #
+      # @example
+      #   result = BrainzLab::Synapse.exec(project_id, command: "rails db:migrate")
+      #
+      def exec(project_id, command:, container: nil, timeout: 30)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.exec(project_id, command: command, container: container, timeout: timeout)
+      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.synapse_enabled
+      end
+    end
+  end
+end

data/lib/brainzlab/testing/event_store.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Testing
+    # Thread-safe store for captured events, logs, errors, and metrics during tests
+    #
+    # This class is used internally by the testing helpers to store all
+    # captured data from stubbed SDK calls.
+    class EventStore
+      def initialize
+        @mutex = Mutex.new
+        @events = []
+        @metrics = []
+        @logs = []
+        @errors = []
+        @error_messages = []
+        @traces = []
+        @alerts = []
+        @notifications = []
+        @triggers = []
+      end
+
+      # === Events (Flux) ===
+
+      def record_event(name, properties = {})
+        @mutex.synchronize do
+          @events << {
+            name: name.to_s,
+            properties: properties,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def events
+        @mutex.synchronize { @events.dup }
+      end
+
+      def events_named(name)
+        @mutex.synchronize do
+          @events.select { |e| e[:name] == name.to_s }
+        end
+      end
+
+      def event_tracked?(name, properties = nil)
+        @mutex.synchronize do
+          @events.any? do |event|
+            next false unless event[:name] == name.to_s
+            next true if properties.nil?
+
+            properties_match?(event[:properties], properties)
+          end
+        end
+      end
+
+      def last_event
+        @mutex.synchronize { @events.last }
+      end
+
+      def clear_events!
+        @mutex.synchronize { @events.clear }
+      end
+
+      # === Metrics (Flux) ===
+
+      def record_metric(type, name, value, opts = {})
+        @mutex.synchronize do
+          @metrics << {
+            type: type.to_sym,
+            name: name.to_s,
+            value: value,
+            tags: opts[:tags] || {},
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def metrics
+        @mutex.synchronize { @metrics.dup }
+      end
+
+      def metrics_named(name)
+        @mutex.synchronize do
+          @metrics.select { |m| m[:name] == name.to_s }
+        end
+      end
+
+      def metric_recorded?(type, name, value: nil, tags: nil)
+        @mutex.synchronize do
+          @metrics.any? do |metric|
+            next false unless metric[:type] == type.to_sym
+            next false unless metric[:name] == name.to_s
+            next false if value && metric[:value] != value
+            next false if tags && !properties_match?(metric[:tags], tags)
+
+            true
+          end
+        end
+      end
+
+      def clear_metrics!
+        @mutex.synchronize { @metrics.clear }
+      end
+
+      # === Logs (Recall) ===
+
+      def record_log(level, message, data = {})
+        @mutex.synchronize do
+          @logs << {
+            level: level.to_sym,
+            message: message.to_s,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def logs
+        @mutex.synchronize { @logs.dup }
+      end
+
+      def logs_at_level(level)
+        @mutex.synchronize do
+          @logs.select { |l| l[:level] == level.to_sym }
+        end
+      end
+
+      def logged?(level, message = nil, data = nil)
+        @mutex.synchronize do
+          @logs.any? do |log|
+            next false unless log[:level] == level.to_sym
+            next true if message.nil?
+
+            message_matches = case message
+                              when Regexp
+                                log[:message].match?(message)
+                              else
+                                log[:message].include?(message.to_s)
+                              end
+
+            next false unless message_matches
+            next true if data.nil?
+
+            properties_match?(log[:data], data)
+          end
+        end
+      end
+
+      def clear_logs!
+        @mutex.synchronize { @logs.clear }
+      end
+
+      # === Errors (Reflex) ===
+
+      def record_error(exception, context = {})
+        @mutex.synchronize do
+          @errors << {
+            exception: exception,
+            error_class: exception.class.name,
+            message: exception.message,
+            backtrace: exception.backtrace,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def record_error_message(message, level, context = {})
+        @mutex.synchronize do
+          @error_messages << {
+            message: message.to_s,
+            level: level.to_sym,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def errors
+        @mutex.synchronize { @errors.dup }
+      end
+
+      def error_messages
+        @mutex.synchronize { @error_messages.dup }
+      end
+
+      def error_captured?(error_class = nil, message: nil, context: nil)
+        @mutex.synchronize do
+          @errors.any? do |error|
+            if error_class
+              next false unless error[:error_class] == error_class.to_s ||
+                                (error_class.is_a?(Class) && error[:exception].is_a?(error_class))
+            end
+
+            if message
+              message_matches = case message
+                                when Regexp
+                                  error[:message].match?(message)
+                                else
+                                  error[:message].include?(message.to_s)
+                                end
+              next false unless message_matches
+            end
+
+            next false if context && !properties_match?(error[:context], context)
+
+            true
+          end
+        end
+      end
+
+      def last_error
+        @mutex.synchronize { @errors.last }
+      end
+
+      def clear_errors!
+        @mutex.synchronize do
+          @errors.clear
+          @error_messages.clear
+        end
+      end
+
+      # === Traces (Pulse) ===
+
+      def record_trace(name, opts = {})
+        @mutex.synchronize do
+          @traces << {
+            name: name.to_s,
+            options: opts,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def traces
+        @mutex.synchronize { @traces.dup }
+      end
+
+      def trace_recorded?(name, opts = nil)
+        @mutex.synchronize do
+          @traces.any? do |trace|
+            next false unless trace[:name] == name.to_s
+            next true if opts.nil?
+
+            properties_match?(trace[:options], opts)
+          end
+        end
+      end
+
+      def clear_traces!
+        @mutex.synchronize { @traces.clear }
+      end
+
+      # === Alerts (Signal) ===
+
+      def record_alert(name, message, severity, channels, data)
+        @mutex.synchronize do
+          @alerts << {
+            name: name.to_s,
+            message: message.to_s,
+            severity: severity.to_sym,
+            channels: channels,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def alerts
+        @mutex.synchronize { @alerts.dup }
+      end
+
+      def alert_sent?(name, message: nil, severity: nil)
+        @mutex.synchronize do
+          @alerts.any? do |alert|
+            next false unless alert[:name] == name.to_s
+            next false if message && !alert[:message].include?(message.to_s)
+            next false if severity && alert[:severity] != severity.to_sym
+
+            true
+          end
+        end
+      end
+
+      def clear_alerts!
+        @mutex.synchronize { @alerts.clear }
+      end
+
+      # === Notifications (Signal) ===
+
+      def record_notification(channel, message, title, data)
+        @mutex.synchronize do
+          @notifications << {
+            channel: Array(channel).map(&:to_s),
+            message: message.to_s,
+            title: title,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def notifications
+        @mutex.synchronize { @notifications.dup }
+      end
+
+      def clear_notifications!
+        @mutex.synchronize { @notifications.clear }
+      end
+
+      # === Triggers (Signal) ===
+
+      def record_trigger(rule_name, context)
+        @mutex.synchronize do
+          @triggers << {
+            rule_name: rule_name.to_s,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def triggers
+        @mutex.synchronize { @triggers.dup }
+      end
+
+      def clear_triggers!
+        @mutex.synchronize { @triggers.clear }
+      end
+
+      # === General ===
+
+      def clear!
+        @mutex.synchronize do
+          @events.clear
+          @metrics.clear
+          @logs.clear
+          @errors.clear
+          @error_messages.clear
+          @traces.clear
+          @alerts.clear
+          @notifications.clear
+          @triggers.clear
+        end
+      end
+
+      def empty?
+        @mutex.synchronize do
+          @events.empty? &&
+            @metrics.empty? &&
+            @logs.empty? &&
+            @errors.empty? &&
+            @error_messages.empty? &&
+            @traces.empty? &&
+            @alerts.empty? &&
+            @notifications.empty? &&
+            @triggers.empty?
+        end
+      end
+
+      private
+
+      def properties_match?(actual, expected)
+        expected.all? do |key, value|
+          actual_value = actual[key] || actual[key.to_s] || actual[key.to_sym]
+
+          case value
+          when Regexp
+            actual_value.to_s.match?(value)
+          else
+            actual_value == value
+          end
+        end
+      end
+    end
+  end
+end