brainzlab 0.1.1 → 0.1.2

data/lib/brainzlab/synapse/client.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Synapse
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.synapse_url || "https://synapse.brainzlab.ai"
+      end
+
+      # List all projects
+      def list_projects(status: nil, page: 1, per_page: 20)
+        params = { page: page, per_page: per_page }
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/projects", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:projects] || []
+      rescue StandardError => e
+        log_error("list_projects", e)
+        []
+      end
+
+      # Get project details
+      def get_project(project_id)
+        response = request(:get, "/api/v1/projects/#{project_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_project", e)
+        nil
+      end
+
+      # Create a new project
+      def create_project(name:, repos: [], description: nil, **options)
+        response = request(
+          :post,
+          "/api/v1/projects",
+          body: {
+            name: name,
+            description: description,
+            repos: repos,
+            **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("create_project", e)
+        nil
+      end
+
+      # Start project containers
+      def start_project(project_id)
+        response = request(:post, "/api/v1/projects/#{project_id}/up")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("start_project", e)
+        false
+      end
+
+      # Stop project containers
+      def stop_project(project_id)
+        response = request(:post, "/api/v1/projects/#{project_id}/down")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("stop_project", e)
+        false
+      end
+
+      # Restart project containers
+      def restart_project(project_id)
+        response = request(:post, "/api/v1/projects/#{project_id}/restart")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("restart_project", e)
+        false
+      end
+
+      # Deploy project to environment
+      def deploy(project_id, environment:, options: {})
+        response = request(
+          :post,
+          "/api/v1/projects/#{project_id}/deploy",
+          body: {
+            environment: environment,
+            **options
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("deploy", e)
+        nil
+      end
+
+      # Get deployment status
+      def get_deployment(deployment_id)
+        response = request(:get, "/api/v1/deployments/#{deployment_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_deployment", e)
+        nil
+      end
+
+      # Create an AI task
+      def create_task(project_id:, description:, type: nil, priority: nil, **options)
+        response = request(
+          :post,
+          "/api/v1/tasks",
+          body: {
+            project_id: project_id,
+            description: description,
+            type: type,
+            priority: priority,
+            **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("create_task", e)
+        nil
+      end
+
+      # Get task status
+      def get_task(task_id)
+        response = request(:get, "/api/v1/tasks/#{task_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_task", e)
+        nil
+      end
+
+      # Get task status and progress
+      def get_task_status(task_id)
+        response = request(:get, "/api/v1/tasks/#{task_id}/status")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_task_status", e)
+        nil
+      end
+
+      # List tasks for a project
+      def list_tasks(project_id: nil, status: nil, page: 1, per_page: 20)
+        params = { page: page, per_page: per_page }
+        params[:project_id] = project_id if project_id
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/tasks", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:tasks] || []
+      rescue StandardError => e
+        log_error("list_tasks", e)
+        []
+      end
+
+      # Cancel a running task
+      def cancel_task(task_id)
+        response = request(:post, "/api/v1/tasks/#{task_id}/cancel")
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("cancel_task", e)
+        false
+      end
+
+      # Get container logs
+      def get_logs(project_id, container: nil, lines: 100, since: nil)
+        params = { lines: lines }
+        params[:container] = container if container
+        params[:since] = since if since
+
+        response = request(:get, "/api/v1/projects/#{project_id}/logs", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_logs", e)
+        nil
+      end
+
+      # Execute command in container
+      def exec(project_id, command:, container: nil, timeout: 30)
+        response = request(
+          :post,
+          "/api/v1/projects/#{project_id}/exec",
+          body: {
+            command: command,
+            container: container,
+            timeout: timeout
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("exec", 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 = 120  # Longer timeout for AI tasks
+
+        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.synapse_master_key || @config.secret_key
+        else
+          auth_key = @config.synapse_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("[Synapse::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/synapse/provisioner.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Synapse
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.synapse_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("[Synapse::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Synapse::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.synapse_api_key || @config.synapse_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/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, **options)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.synapse_valid?
+
+        client.create_project(name: name, repos: repos, description: description, **options)
+      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, **options)
+        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,
+          **options
+        )
+      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