strata-cli 0.1.8 → 0.1.10

data/lib/strata/cli/guard.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "utils"
+require_relative "output"
+
 module Strata
   module CLI
     module Guard
@@ -10,13 +12,14 @@ module Strata
         adapters
         version
         deploy
+        branch
       ].freeze
 
       def invoke_command(command, *args)
         Utils.exit_error_if_not_strata! unless ALLOWED_COMMANDS.include?(command.name)
         super
       rescue Strata::CommandError => e
-        shell.say_error "ERROR: #{e.message}", :red
+        Output.print_error("ERROR: #{e.message}", context: self)
         exit 1
       end
     end

data/lib/strata/cli/helpers/command_context.rb

@@ -2,7 +2,7 @@
 
 require "tty-prompt"
 require_relative "datasource_helper"
-require_relative "color_helper"
+require_relative "../output"
 require_relative "prompts"
 require_relative "../error_reporter"
 
@@ -10,6 +10,7 @@ module Strata
   module CLI
     module Helpers
       module CommandContext
+        include Output
         include DatasourceHelper
 
         def adapter
@@ -28,8 +29,7 @@ module Strata
           @table_fetch_result ||= begin
             tables = with_spinner("Fetching tables from #{datasource_key}...") { adapter.tables }
             if tables.empty?
-              # Assuming Prompts and ColorHelper are available in the class or via module
-              say Prompts::MSG_NO_TABLES_FOUND % datasource_key, ColorHelper.warning
+              say(Output.format(:warning, Prompts::MSG_NO_TABLES_FOUND % datasource_key), nil) if respond_to?(:say)
               {tables: [], failed: false}
             else
               {tables: tables, failed: false}
@@ -38,15 +38,14 @@ module Strata
             ErrorReporter.log_error(e, context: "create table: failed fetching tables for '#{datasource_key}'")
 
             if ErrorReporter.connection_error?(e)
-              say "Could not connect to datasource '#{datasource_key}'.", ColorHelper.warning
+              say(Output.format(:warning, "Could not connect to datasource '#{datasource_key}'."), nil) if respond_to?(:say)
             else
-              say "Could not fetch tables from datasource '#{datasource_key}'.", ColorHelper.warning
-              say "Reason: #{ErrorReporter.user_message_for(e)}", ColorHelper.warning
+              say(Output.format(:warning, "Could not fetch tables from datasource '#{datasource_key}'."), nil) if respond_to?(:say)
+              say(Output.format(:warning, "Reason: #{ErrorReporter.user_message_for(e)}"), nil) if respond_to?(:say)
             end
 
-            say "Hint: verify credentials/settings and run 'strata datasource test #{datasource_key}'.",
-              ColorHelper.info
-            say "Details logged to '#{ErrorReporter.log_relative_path}'.", ColorHelper.info
+            say(Output.format(:dim, "Hint: verify credentials/settings and run 'strata datasource test #{datasource_key}'."), nil) if respond_to?(:say)
+            say(Output.format(:info, "Details logged to '#{ErrorReporter.log_relative_path}'."), nil) if respond_to?(:say)
             {tables: [], failed: true}
           end
         end

data/lib/strata/cli/helpers/datasource_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../agent_output"
+
 module Strata
   module CLI
     module DatasourceHelper
@@ -8,7 +10,7 @@ module Strata
         redshift: %w[pg],
         mysql: %w[mysql2],
         sqlserver: %w[tiny_tds],
-        athena: %w[aws-sdk-athena aws-sdk-s3],
+        athena: %w[aws-sdk-athena aws-sdk-s3 rexml],
         trino: %w[trino-client],
         sqlite: %w[sqlite3],
         duckdb: %w[duckdb]
@@ -24,6 +26,19 @@ module Strata
         # 3. Check available datasources
         ds_keys = datasources.keys
 
+        if agent_mode?
+          if ds_keys.empty?
+            agent_emit_no_datasources!
+          elsif ds_keys.length == 1
+            return ds_keys.first
+          else
+            AgentOutput.emit_error(
+              "Datasource key required. Available: #{ds_keys.join(", ")}",
+              code: "datasource_key_required"
+            )
+          end
+        end
+
         if ds_keys.empty?
           say "No datasources configured. Run 'strata datasource add' first.", :red
           nil
@@ -134,6 +149,17 @@ module Strata
 
       private
 
+      def agent_emit_no_datasources!
+        AgentOutput.emit_error(
+          "No datasources configured in datasources.yml. Ask the user to add one interactively — " \
+          "do not create datasources or write credentials yourself (secrets belong in .strata via CLI prompts). " \
+          "User command: strata datasource add [ADAPTER] (e.g. strata datasource add postgres, strata datasource add duckdb).",
+          code: "no_datasources",
+          user_action_required: true,
+          suggested_command: "strata datasource add [ADAPTER]"
+        )
+      end
+
       def validate_datasource(ds_key)
         unless datasources[ds_key]
           say "Error: Datasource '#{ds_key}' not found in datasources.yml", :red

data/lib/strata/cli/helpers/description_helper.rb

@@ -11,7 +11,8 @@ module Strata
           if File.exist?(file_path)
             long_desc File.read(file_path)
           else
-            warn "Warning: Description file not found at #{file_path}"
+            require_relative "../output"
+            Output.print_warning("Warning: Description file not found at #{file_path}")
           end
         end
       end

data/lib/strata/cli/main.rb

@@ -3,16 +3,21 @@
 require_relative "generators/project"
 require_relative "sub_commands/datasource"
 require_relative "sub_commands/deploy"
+require_relative "sub_commands/branch"
 require_relative "sub_commands/project"
 require_relative "sub_commands/table"
 require_relative "sub_commands/create"
 require_relative "sub_commands/audit"
 require_relative "helpers/description_helper"
+require_relative "agent_mode"
+require_relative "output"
 
 module Strata
   module CLI
     class Main < Thor
       include Guard
+      include Output
+      include AgentMode
       extend Helpers::DescriptionHelper
 
       def self.exit_on_failure?
@@ -30,21 +35,22 @@ module Strata
         repeatable: true
       option :source, aliases: ["s"], type: :string, desc: "URL of existing project"
       option :api_key, aliases: ["a"], type: :string, desc: "Api Key. Required if initializing existing project."
+      option :verbose, aliases: ["v"], type: :boolean, default: false,
+        desc: "Show detailed init output (file-by-file actions)."
 
       def init(project_name = nil)
         unless project_name || options[:source]
           raise Strata::CommandError, "PROJECT_NAME is required when not using --source option."
         end
 
-        say_status :started, "Creating #{project_name || "project from source"} - #{options[:datasource]}",
-          ColorHelper.info
+        print_status(:created, (project_name || "project from source").to_s, type: :info)
         invoke Generators::Project, [project_name], options
       end
 
       desc "adapters", "Lists supported data warehouse adapters"
       def adapters
         out = " SUPPORTED ADAPTERS: \n\t#{DWH.adapters.keys.join("\n\t")}"
-        say out, ColorHelper.info
+        print_info(out)
       end
 
       desc "datasource", "Manage project datasources"
@@ -62,6 +68,9 @@ module Strata
       desc "deploy", "Deploy project to Strata server"
       subcommand "deploy", SubCommands::Deploy
 
+      desc "branch", "Manage Strata server branches"
+      subcommand "branch", SubCommands::Branch
+
       desc "project", "Manage project configuration"
       subcommand "project", SubCommands::Project
 

data/lib/strata/cli/output.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "thor"
+require "pastel"
+
+module Strata
+  module CLI
+    module Output
+      THEME = {
+        success: :green,
+        error: %i[red bold],
+        warning: :yellow,
+        info: :cyan,
+        title: %i[cyan bold],
+        highlight: %i[cyan bold],
+        dim: :bright_black,
+        primary: :blue,
+        secondary: :magenta,
+        border: %i[cyan dim],
+        selected: %i[green bold],
+        disabled: :bright_black
+      }.freeze
+
+      class << self
+        def pastel
+          @pastel ||= Pastel.new(enabled: $stdout.tty?)
+        end
+
+        def shell_for(context = nil)
+          return context.shell if context&.respond_to?(:shell)
+          return context if context.is_a?(Thor::Shell)
+
+          Thor::Shell::Color.new
+        end
+
+        def print_info(message, context: nil)
+          shell_for(context).say(format(:info, message))
+        end
+
+        def print_success(message, context: nil)
+          shell_for(context).say(format(:success, message))
+        end
+
+        def print_warning(message, context: nil)
+          shell_for(context).say(format(:warning, message))
+        end
+
+        def print_error(message, context: nil)
+          shell_for(context).say_error(format(:error, message))
+        end
+
+        def print_hint(message, context: nil, stderr: false)
+          shell = shell_for(context)
+          formatted = format(:dim, message)
+          stderr ? shell.say_error(formatted) : shell.say(formatted)
+        end
+
+        # Standard status output with Thor's prefix formatting.
+        # We keep the label color via Thor, but decorate the message via Output theme.
+        def print_status(label, message, type: :info, context: nil)
+          shell = shell_for(context)
+          shell.say_status(label, format(type, message), thor_color(type))
+        end
+
+        def format(type, message)
+          return "" if message.nil?
+
+          styles = THEME[type]
+          return message.to_s unless styles
+
+          if styles.is_a?(Array)
+            pastel.decorate(message.to_s, *styles)
+          else
+            pastel.send(styles, message.to_s)
+          end
+        end
+
+        # Thor only understands a limited palette; keep it simple/stable.
+        def thor_color(type)
+          case type
+          when :success then :green
+          when :error then :red
+          when :warning then :yellow
+          when :info, :title, :border then :cyan
+          when :primary then :blue
+          when :secondary then :magenta
+          when :dim then :white
+          else
+            :white
+          end
+        end
+      end
+
+      # Convenience instance methods for Thor classes.
+      def print_info(message) = Output.print_info(message, context: self)
+      def print_success(message) = Output.print_success(message, context: self)
+      def print_warning(message) = Output.print_warning(message, context: self)
+      def print_error(message) = Output.print_error(message, context: self)
+      def print_hint(message, stderr: false) = Output.print_hint(message, context: self, stderr: stderr)
+      def print_status(label, message, type: :info) = Output.print_status(label, message, type: type, context: self)
+    end
+  end
+end

data/lib/strata/cli/sub_commands/audit.rb

@@ -3,8 +3,9 @@
 require_relative "../guard"
 require_relative "../terminal"
 require_relative "../credentials"
-require_relative "../helpers/color_helper"
+require_relative "../output"
 require_relative "../helpers/datasource_helper"
+require_relative "../agent_mode"
 require_relative "../utils/yaml_import_resolver"
 require_relative "../utils/import_manager"
 require "yaml"
@@ -17,12 +18,22 @@ module Strata
         include Thor::Actions
         include Guard
         include Terminal
+        include Output
         include DatasourceHelper
+        include AgentMode
 
         REQUIRED_KEYS_FOR_TABLE_MODEL = %w[name physical_name fields datasource].freeze
         REQUIRED_KEYS_FOR_RELATIONSHIP_MODEL = ["datasource"].freeze
         REQUIRED_KEYS_FOR_RELATIONSHIP_DEFINITION = %w[left right sql cardinality].freeze
         RELATIONSHIP_CARDINALITIES = %w[one_to_one one_to_many many_to_one many_to_many].freeze
+        VALID_FORMAT_TYPES = %w[raw number currency percent date datetime html javascript].freeze
+        ALLOWED_FIELD_KEYS = %w[
+          type name description hidden grains data_type display_type format
+          secure disable_listing value_list_size snapshot exclusion_type
+          exclusions inclusions extended_blend_group synonyms expression
+        ].freeze
+        ALLOWED_EXPRESSION_KEYS = %w[sql array lookup primary_key].freeze
+        EXPRESSION_BOOLEAN_KEYS = %w[array lookup primary_key].freeze
 
         # Set default command so `strata audit` still works as `strata audit all`
         default_command :all
@@ -61,7 +72,7 @@ module Strata
           if results.values.all?
             # All checks passed - no need for additional message, spinners already show success
           else
-            say "\n Some checks failed.", ColorHelper.error
+            print_error("\n Some checks failed.")
             exit(1)
           end
         end
@@ -76,7 +87,7 @@ module Strata
         rescue
           failures.each do |f|
             msg = f.is_a?(Hash) ? "#{f[:file]}: #{f[:message]}" : f.to_s
-            say "  ✖ #{msg}", ColorHelper.error
+            print_error("  ✖ #{msg}")
           end
           false
         end
@@ -98,8 +109,8 @@ module Strata
         def audit_models
           failures = []
           Dir.glob("models/**/*.yml").each do |file|
-            audit_model_file(file, failures)
             audit_imports(file, failures)
+            audit_model_file(file, failures)
           end
           failures
         end
@@ -108,17 +119,21 @@ module Strata
           content = YAML.safe_load_file(file, permitted_classes: [Date, Time], aliases: true) || {}
           return unless content.is_a?(Hash)
 
-          validate_structure(content, file, failures)
-
           case model_type(file)
           when :table
-            validate_table_model(content, file, failures)
+            resolved = Utils::YamlImportResolver.resolve(file, Dir.pwd)
+            return unless resolved.is_a?(Hash)
+
+            validate_structure(resolved, file, failures)
+            validate_table_model(resolved, file, failures)
           when :relationship
+            validate_structure(content, file, failures)
             validate_relationship_model(content, file, failures)
           end
-        rescue
-          # Ignore errors here, they are handled in audit_yaml_syntax if needed
-          # or simply skipped if the file is unreadable
+        rescue Strata::ImportError => e
+          failures << {file: file, message: e.message}
+        rescue Psych::SyntaxError
+          # Handled by audit_yaml_syntax when run
         end
 
         def model_type(file)
@@ -139,7 +154,7 @@ module Strata
         def validate_table_model(content, file, failures)
           validate_required_keys(content, file, REQUIRED_KEYS_FOR_TABLE_MODEL, failures)
           validate_datasource_reference(content, file, failures)
-          validate_table_fields(content["fields"], file, failures) if content.key?("fields")
+          validate_table_fields(content["fields"], file, failures)
         end
 
         def validate_relationship_model(content, file, failures)
@@ -171,10 +186,119 @@ module Strata
             return
           end
 
+          if fields.empty?
+            failures << {file: file, message: "'fields' must not be empty"}
+            return
+          end
+
           fields.each_with_index do |field, idx|
             unless field.is_a?(Hash) && field.key?("name")
               failures << {file: file, message: "Field at index #{idx} missing 'name'"}
+              next
+            end
+
+            validate_field_definition(field, file, idx, failures)
+          end
+        end
+
+        def validate_field_definition(field, file, idx, failures)
+          field_name = field["name"] || "index #{idx}"
+
+          unknown_keys = field.keys.map(&:to_s) - ALLOWED_FIELD_KEYS
+          if unknown_keys.any?
+            failures << {
+              file: file,
+              message: "Field '#{field_name}' has unknown #{(unknown_keys.size == 1) ? "key" : "keys"}: #{unknown_keys.sort.join(", ")}"
+            }
+          end
+
+          validate_field_expression(field_name, field["expression"], file, failures)
+
+          return unless field.key?("format")
+
+          validate_field_format(field_name, field["format"], file, failures)
+        end
+
+        def validate_field_expression(field_name, expression, file, failures)
+          if expression.nil?
+            failures << {file: file, message: "Field '#{field_name}' missing required 'expression'"}
+            return
+          end
+
+          if expression.is_a?(String)
+            if expression.strip.empty?
+              failures << {file: file, message: "Field '#{field_name}' expression must not be empty"}
+            end
+            return
+          end
+
+          unless expression.is_a?(Hash)
+            type_name = expression.class.name
+            failures << {
+              file: file,
+              message: "Field '#{field_name}' expression must be a string shortcut or a mapping (got #{type_name})"
+            }
+            return
+          end
+
+          unknown_keys = expression.keys.map(&:to_s) - ALLOWED_EXPRESSION_KEYS
+          if unknown_keys.any?
+            failures << {
+              file: file,
+              message: "Field '#{field_name}' expression has unknown #{(unknown_keys.size == 1) ? "key" : "keys"}: " \
+                "#{unknown_keys.sort.join(", ")}"
+            }
+          end
+
+          sql = expression["sql"] || expression[:sql]
+          if sql.nil? || sql.to_s.strip.empty?
+            failures << {file: file, message: "Field '#{field_name}' expression must include non-empty 'sql'"}
+          end
+
+          EXPRESSION_BOOLEAN_KEYS.each do |key|
+            next unless expression.key?(key) || expression.key?(key.to_sym)
+
+            value = expression[key] || expression[key.to_sym]
+            next if value == true || value == false
+
+            failures << {
+              file: file,
+              message: "Field '#{field_name}' expression.#{key} must be true or false"
+            }
+          end
+        end
+
+        def validate_field_format(field_name, format_value, file, failures)
+          case format_value
+          when String
+            shortcut = format_value.strip
+            if shortcut.empty?
+              failures << {file: file, message: "Field '#{field_name}' format must not be empty"}
+              return
+            end
+
+            type = shortcut.split(":", 2).first
+            unless VALID_FORMAT_TYPES.include?(type)
+              failures << {
+                file: file,
+                message: "Field '#{field_name}' format shortcut has invalid type '#{type}' (expected one of: #{VALID_FORMAT_TYPES.join(", ")})"
+              }
+            end
+          when Hash
+            type = format_value["type"] || format_value[:type]
+            if type.nil? || type.to_s.strip.empty?
+              failures << {file: file, message: "Field '#{field_name}' format hash must include type"}
+            elsif !VALID_FORMAT_TYPES.include?(type.to_s)
+              failures << {
+                file: file,
+                message: "Field '#{field_name}' format hash has invalid type '#{type}' (expected one of: #{VALID_FORMAT_TYPES.join(", ")})"
+              }
             end
+          else
+            failures << {
+              file: file,
+              message: "Field '#{field_name}' format must be a string shortcut or a hash with type"
+            }
           end
         end
 
@@ -253,13 +377,9 @@ module Strata
             imported_content = YAML.safe_load_file(resolved_path, permitted_classes: [Date, Time], aliases: true) || {}
 
             unless imported_content.is_a?(Hash)
-              failures << {file: file, message: "Imported file '#{import_path}' does not contain valid YAML hash"}
+              failures << {file: file, message: "Imported file '#{import_path}' does not contain valid YAML"}
               next
             end
-
-            if model_type(file) == :table && imported_content["fields"]
-              validate_table_fields(imported_content["fields"], file, failures)
-            end
           rescue Strata::InvalidImportPathError => e
             failures << {file: file, message: e.message}
           rescue Strata::MissingImportError