strata-cli 0.1.0.beta

data/lib/strata/cli/ai/services/table_generator.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require_relative "../client"
+require "yaml"
+
+module Strata
+  module CLI
+    module AI
+      module Services
+        # Generates semantic model fields from database table metadata using AI.
+        # Returns structured JSON for use in the field editor.
+        class TableGenerator
+          SYSTEM_PROMPT = <<~PROMPT
+            You are a semantic modeling expert for analytics and BI systems.
+            Analyze database columns and generate semantic field definitions.
+
+            For each column, determine:
+            - name: Human-friendly field name (e.g., "customer_id" → "Customer ID")
+            - description: Brief description of what this field represents
+            - schema_type: "dimension" for categorical/text, "measure" for numeric aggregations
+            - data_type: string, integer, bigint, decimal, date, date_time, boolean
+            - expression: SQL expression (for measures include aggregation like "sum(amount)")
+
+            Output ONLY valid JSON array, no explanations.
+          PROMPT
+
+          attr_reader :client
+
+          def initialize(client: Client.new)
+            @client = client
+          end
+
+          # Generate field definitions from table metadata
+          # @param table_name [String] Full table name (schema.table)
+          # @param columns [Array<Hash>] Column metadata with :name, :type
+          # @param datasource [String] Datasource key
+          # @param user_context [Hash, nil] Optional user-provided context with :description
+          # @return [Hash, nil] Generated model data or nil if AI disabled
+          def call(table_name:, columns:, datasource:, user_context: nil)
+            unless ai_available?
+              warn "AI not available - using rule-based fallback"
+              return fallback_fields(columns)
+            end
+
+            existing_models = load_existing_models_context
+            prompt = build_prompt(
+              table_name: table_name,
+              columns: columns,
+              existing_models_context: existing_models,
+              user_context: user_context
+            )
+
+            begin
+              response = @client.complete(prompt, system_prompt: SYSTEM_PROMPT)
+              parse_response(response, columns)
+            rescue => e
+              # Fallback to basic field generation on AI error
+              warn "AI failed to generate fields: #{e.message} - performing basic field generation"
+              fallback_fields(columns)
+            end
+          end
+
+          # Generate fields with user prompt for modification/regeneration
+          # @param table_name [String] Full table name
+          # @param columns [Array<Hash>] Column metadata
+          # @param datasource [String] Datasource key
+          # @param user_prompt [String] User's natural language prompt
+          # @param current_fields [Array<Hash>] Current field definitions
+          # @return [Array<Hash>] Regenerated fields
+          def call_with_prompt(table_name:, columns:, datasource:, user_prompt:, current_fields:)
+            unless ai_available?
+              warn "AI not available - could not use prompt mode"
+              return nil
+            end
+
+            prompt = build_prompt_with_user_input(
+              table_name: table_name,
+              columns: columns,
+              user_prompt: user_prompt,
+              current_fields: current_fields
+            )
+
+            begin
+              response = @client.complete(prompt, system_prompt: SYSTEM_PROMPT)
+              parse_response(response, columns)
+            rescue => e
+              warn "AI failed to generate fields: #{e.message}"
+              nil
+            end
+          end
+
+          # Check if AI is available
+          def ai_available?
+            @client.enabled?
+          end
+
+          private
+
+          def build_prompt(table_name:, columns:, existing_models_context: nil, user_context: nil)
+            column_list = columns.map do |col|
+              name = col[:name] || col["name"]
+              type = col[:type] || col["type"]
+              "- #{name}: #{type}"
+            end.join("\n")
+
+            context_section = if existing_models_context && !existing_models_context.empty?
+              "\n\nExisting model patterns for consistency:\n#{existing_models_context}"
+            else
+              ""
+            end
+
+            user_context_section = if user_context && !user_context[:description].to_s.empty?
+              "\n\nBusiness context provided by user: #{user_context[:description]}"
+            else
+              ""
+            end
+
+            <<~PROMPT
+              Analyze these columns from table "#{table_name}" and generate semantic field definitions:
+
+              #{column_list}#{context_section}#{user_context_section}
+
+              Return JSON array with objects containing: name, description, schema_type, data_type, expression
+              Example: [{"name": "Order ID", "description": "Primary key", "schema_type": "dimension", "data_type": "bigint", "expression": "id"}]
+            PROMPT
+          end
+
+          def build_prompt_with_user_input(table_name:, columns:, user_prompt:, current_fields:)
+            column_list = columns.map do |col|
+              name = col[:name] || col["name"]
+              type = col[:type] || col["type"]
+              "- #{name}: #{type}"
+            end.join("\n")
+
+            current_fields_summary = current_fields.map do |f|
+              "- #{f[:name] || f["name"]}: #{f[:schema_type] || f["schema_type"]} (#{f[:expression] || f["expression"]})"
+            end.join("\n")
+
+            existing_models = load_existing_models_context
+            context_section = if existing_models && !existing_models.empty?
+              "\n\nExisting model patterns for consistency:\n#{existing_models}"
+            else
+              ""
+            end
+
+            <<~PROMPT
+              User request: #{user_prompt}
+
+              Current fields:
+              #{current_fields_summary}
+
+              Table columns:
+              #{column_list}#{context_section}
+
+              Based on the user's request, regenerate or modify the field definitions.
+              Return JSON array with objects containing: name, description, schema_type, data_type, expression
+            PROMPT
+          end
+
+          def load_existing_models_context
+            return nil unless Dir.exist?("models")
+
+            model_files = Dir.glob("models/tbl_*.yml").first(5) # Limit to 5 for performance
+            return nil if model_files.empty?
+
+            contexts = model_files.map do |file|
+              model = YAML.safe_load_file(file, permitted_classes: [Date, Time], aliases: true) || {}
+              fields_summary = (model["fields"] || []).map do |f|
+                "#{f["name"]} (#{f["schema_type"]})"
+              end.join(", ")
+              "Model: #{model["name"]} - Fields: #{fields_summary}"
+            rescue => e
+              warn "Failed to load model file #{file}: #{e.message}" if ENV["DEBUG"]
+              nil
+            end.compact
+
+            contexts.join("\n")
+          end
+
+          def parse_response(response, columns)
+            # Clean up response - remove markdown if present
+            json_str = response.gsub(/```json\n?/, "").gsub(/```\n?/, "").strip
+
+            fields = JSON.parse(json_str, symbolize_names: true)
+
+            # Ensure each field has column reference
+            fields.each_with_index do |field, idx|
+              col = columns[idx]
+              field[:column] = col[:name] || col["name"] if col
+            end
+
+            fields
+          rescue JSON::ParserError => e
+            raise AIError, "Failed to parse AI response as JSON: #{e.message}"
+          end
+
+          def fallback_fields(columns)
+            columns.map do |col|
+              name = col[:name] || col["name"]
+              type = col[:type] || col["type"]
+
+              is_measure = should_be_measure?(name, type)
+
+              {
+                column: name,
+                name: humanize(name),
+                description: "",
+                schema_type: is_measure ? "measure" : "dimension",
+                data_type: map_data_type(type),
+                expression: is_measure ? "sum(#{name})" : name
+              }
+            end
+          end
+
+          def humanize(str)
+            str.to_s.tr("_", " ").gsub(/\b\w/, &:upcase)
+          end
+
+          # Smarter logic: only true metrics should be measures
+          def should_be_measure?(name, type)
+            name_lower = name.to_s.downcase
+
+            # These patterns indicate dimensions, not measures
+            dimension_patterns = [
+              /_sk$/,           # Surrogate keys (TPC-DS pattern)
+              /_id$/,           # Foreign/primary keys
+              /_key$/,          # Key columns
+              /_code$/,         # Code columns
+              /_flag$/,         # Boolean flags
+              /_date/,          # Date columns
+              /_year$/,         # Year (attribute, not sum)
+              /_month$/,        # Month (attribute, not sum)
+              /_day$/,          # Day (attribute, not sum)
+              /^id$/,           # Just "id"
+              /created_at/,     # Timestamps
+              /updated_at/,
+              /deleted_at/
+            ]
+
+            return false if dimension_patterns.any? { |pattern| name_lower.match?(pattern) }
+
+            # Measure patterns (things you actually sum)
+            measure_patterns = [
+              /amount/,
+              /price/,
+              /cost/,
+              /total/,
+              /qty/,
+              /quantity/,
+              /count/,
+              /sum/,
+              /revenue/,
+              /sales/,
+              /fee/,
+              /tax/,
+              /discount/
+            ]
+
+            # If name matches measure pattern and is numeric, it's a measure
+            numeric_type?(type) && measure_patterns.any? { |pattern| name_lower.match?(pattern) }
+          end
+
+          def numeric_type?(type)
+            type.to_s.downcase.match?(/int|decimal|numeric|float|double|number/)
+          end
+
+          def map_data_type(type)
+            case type.to_s.downcase
+            when /bigint/, /int8/ then "bigint"
+            when /int/ then "integer"
+            when /decimal/, /numeric/, /float/, /double/ then "decimal"
+            when /bool/ then "boolean"
+            when /timestamp/, /datetime/ then "date_time"
+            when /date/ then "date"
+            else "string"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/api/client.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+require_relative "connection_error_handler"
+
+module Strata
+  module CLI
+    module API
+      class Client
+        include ConnectionErrorHandler
+
+        def initialize(server_url, api_key)
+          @server_url = server_url.chomp("/")
+          @api_key = api_key
+        end
+
+        def last_successful_deployment(project_id, branch_id)
+          url = deployment_url(project_id, branch_id)
+          response = with_connection_error_handling(@server_url) { connection.get(url) }
+          deployments = handle_response(response)
+
+          return nil unless deployments.is_a?(Array)
+
+          # Find the first successful deployment
+          deployments.find { |d| d["status"] == "succeeded" }
+        end
+
+        def create_deployment(project_id, branch_id, archive_path, metadata)
+          url = deployment_url(project_id, branch_id)
+          file = Faraday::Multipart::FilePart.new(
+            archive_path,
+            "application/gzip"
+          )
+
+          response = with_connection_error_handling(@server_url) do
+            connection.post(url) do |req|
+              req.body = {
+                "deployment[archive]" => file,
+                "deployment[commit]" => metadata[:commit],
+                "deployment[commit_message]" => metadata[:commit_message],
+                "deployment[committer_name]" => metadata[:committer_name],
+                "deployment[committer_email]" => metadata[:committer_email],
+                "deployment[file_modifications]" => metadata[:file_modifications].to_json
+              }
+            end
+          end
+
+          handle_response(response)
+        end
+
+        def get_deployment(project_id, branch_id, deployment_id)
+          url = "#{deployment_url(project_id, branch_id)}/#{deployment_id}"
+          response = with_connection_error_handling(@server_url) { connection.get(url) }
+          handle_response(response)
+        end
+
+        def latest_deployment(project_id, branch_id)
+          url = deployment_url(project_id, branch_id)
+          response = with_connection_error_handling(@server_url) { connection.get(url) }
+          deployments = handle_response(response)
+          return nil unless deployments.is_a?(Array) && deployments.any?
+
+          deployments.first
+        end
+
+        def create_project(name, uid, description: nil, git: nil, production_branch: "main")
+          url = "#{@server_url}/api/v1/projects"
+          response = with_connection_error_handling(@server_url) do
+            connection.post(url) do |req|
+              req.headers["Content-Type"] = "application/json"
+              req.body = {
+                project: {
+                  name: name,
+                  uid: uid,
+                  description: description,
+                  git: git
+                },
+                production_branch: production_branch
+              }.to_json
+            end
+          end
+
+          handle_response(response)
+        end
+
+        private
+
+        def connection
+          @connection ||= Faraday.new(url: @server_url) do |f|
+            f.request :multipart
+            f.request :authorization, "Bearer", @api_key
+            f.response :json
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        def handle_response(response)
+          case response.status
+          when 200..299
+            response.body
+          when 401
+            raise Strata::CommandError, "Authentication failed. Check your API key."
+          when 403
+            raise Strata::CommandError, "Access denied. You don't have permission for this action."
+          when 404
+            raise Strata::CommandError, "Resource not found."
+          when 422
+            errors = extract_errors(response.body)
+            raise Strata::CommandError, "Validation failed: #{errors}"
+          when 500..599
+            raise Strata::CommandError, "Server error: #{response.status}"
+          else
+            raise Strata::CommandError, "Unexpected response: #{response.status}"
+          end
+        rescue Faraday::Error => e
+          raise Strata::CommandError, "Network error: #{e.message}"
+        end
+
+        def extract_errors(body)
+          # Handle nil or empty body
+          return "Unknown error" if body.nil? || body.empty?
+
+          # Check if it's an HTML error page (Rails error page)
+          if body.is_a?(String) && body.include?("<!DOCTYPE html>")
+            # Try to extract error message from HTML
+            if body =~ /<h1[^>]*>(.*?)<\/h1>/
+              return "Server error: #{$1.strip}"
+            elsif body =~ /<title[^>]*>(.*?)<\/title>/
+              return "Server error: #{$1.strip}"
+            else
+              return "Server returned an HTML error page. Check server logs for details."
+            end
+          end
+
+          # Parse JSON string if needed
+          parsed_body = if body.is_a?(String)
+            begin
+              JSON.parse(body)
+            rescue JSON::ParserError
+              return body[0..200] # Return first 200 chars if not JSON
+            end
+          else
+            body
+          end
+
+          # Extract error messages from various formats
+          if parsed_body.is_a?(Hash)
+            if parsed_body["errors"].is_a?(Array)
+              parsed_body["errors"].join(", ")
+            elsif parsed_body["error"].is_a?(String)
+              parsed_body["error"]
+            elsif parsed_body["message"].is_a?(String)
+              parsed_body["message"]
+            else
+              parsed_body.to_json
+            end
+          else
+            parsed_body.to_s[0..200] # Limit length
+          end
+        end
+
+        def deployment_url(project_id, branch_id)
+          "#{@server_url}/api/v1/projects/#{project_id}/b/#{branch_id}/deploys"
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/api/connection_error_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+module Strata
+  module CLI
+    module API
+      # Handles connection errors and provides user-friendly error messages
+      module ConnectionErrorHandler
+        def with_connection_error_handling(server_url)
+          yield
+        rescue Faraday::ConnectionFailed => e
+          handle_connection_error(server_url, e)
+        rescue Faraday::TimeoutError => e
+          handle_connection_error(server_url, e, timeout: true)
+        rescue Faraday::Error => e
+          # Check if it's a connection-related error
+          if e.message.include?("Connection refused") ||
+              e.message.include?("Failed to open TCP connection") ||
+              e.message.include?("getaddrinfo") ||
+              e.message.include?("No route to host")
+            handle_connection_error(server_url, e)
+          else
+            raise Strata::CommandError, "Network error: #{e.message}"
+          end
+        rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EHOSTUNREACH => e
+          handle_connection_error(server_url, e)
+        end
+
+        private
+
+        def handle_connection_error(server_url, error, timeout: false)
+          server_display = server_url
+
+          message = "\n"
+          message += "Cannot connect to Strata server\n\n"
+          message += "Server: #{server_display}\n"
+
+          if timeout
+            message += "Error: Connection timeout\n\n"
+            message += "The server did not respond in time. This could mean:\n"
+            message += "  • The server is overloaded or slow\n"
+            message += "  • Network connectivity issues\n"
+          else
+            message += "Error: Connection refused\n\n"
+            message += "The server appears to be offline or unreachable. Please check:\n"
+          end
+
+          raise Strata::CommandError, message
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/configuration.rb

@@ -0,0 +1,135 @@
+require "yaml"
+
+module Strata
+  module CLI
+    class Configuration
+      STRATA_CONFIG_FILE = ".strata"
+      PROJECT_CONFIG_FILE = "project.yml"
+
+      # Default configuration
+      DEFAULT = {
+        "api_key" => "",
+        "server" => "http://localhost:3030",
+        "log_level" => "info"
+      }.freeze
+
+      attr_reader :data
+
+      def initialize
+        @data = DEFAULT.merge({})
+        load_config
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @data.key?(method_name.to_s)
+          @data[method_name.to_s]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @data.key?(method_name.to_s) || super
+      end
+
+      def strata_project?
+        File.exist?(project_config_file_path)
+      end
+
+      def config_file_path
+        @config_file_path ||= File.expand_path(STRATA_CONFIG_FILE)
+      end
+
+      def project_config_file_path
+        @project_config_file_path ||= File.expand_path(PROJECT_CONFIG_FILE)
+      end
+
+      # Get configuration value with type conversion
+      def get(key, type: nil)
+        value = self[key]
+        return value unless type
+
+        case type
+        when :boolean
+          convert_to_boolean(value)
+        when :integer
+          Integer(value)
+        when :float
+          Float(value)
+        when :array
+          Array(value)
+        else
+          value
+        end
+      rescue ArgumentError, TypeError => e
+        raise StrataError, "Invalid #{type} value for '#{key}': #{value} \n\t#{e.message}"
+      end
+
+      def reload!
+        @data.clear
+        load_config
+      end
+
+      def get_for_environment(env)
+        root_config = extract_root_config
+        return root_config if env.nil? || env.empty?
+
+        env_data = @data[env.to_s]
+        root_config.merge(env_data)
+      end
+
+      private
+
+      def load_config
+        return unless strata_project?
+
+        strata_data = load_yaml_file(config_file_path)
+        project_data = load_yaml_file(project_config_file_path)
+
+        @data = DEFAULT.merge(strata_data).merge(project_data)
+
+        @api_key = @data["api_key"]
+        @server = @data["server"]
+      end
+
+      def load_yaml_file(file_path)
+        return {} unless File.exist?(file_path)
+
+        YAML.safe_load_file(file_path, permitted_classes: [Date, Time], aliases: true) || {}
+      end
+
+      def extract_root_config
+        root_config = {}
+        @data.each do |key, value|
+          next if is_environment_key?(key, value)
+
+          root_config[key] = value
+        end
+        root_config
+      end
+
+      def is_environment_key?(key, value)
+        return false unless value.is_a?(Hash)
+
+        value.key?("api_key") || value.key?("server")
+      end
+
+      def convert_to_boolean(value)
+        case value
+        when true, false
+          value
+        when "true", "yes", "1", 1
+          true
+        when "false", "no", "0", 0, nil
+          false
+        else
+          raise ArgumentError, "Cannot convert #{value.inspect} to boolean"
+        end
+      end
+    end
+  end
+end