strata-cli 0.1.15 → 0.1.16

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

@@ -0,0 +1,507 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "../utils/sql_expression_parser"
+
+module Strata
+  module CLI
+    # Local mirrors of the server's deploy-time semantic validations, so
+    # `strata audit` (and therefore `strata deploy`, which runs it first)
+    # fails fast with named errors instead of failing mid-deploy on the
+    # server. Each check cites the server code it mirrors (paths in the
+    # strata repo) — keep them in lockstep.
+    #
+    # Server-only checks (universe/path integrity, physical table existence
+    # in the warehouse, licenses) are deliberately not replicated here.
+    module SemanticAuditChecks
+      # deployer/handlers/table.rb dispatches on the literal string
+      # "dimension"; any other value silently becomes a measure and a
+      # missing type crashes the deployer.
+      FIELD_TYPES = %w[dimension measure].freeze
+      # semantic/field.rb enums — invalid values raise a raw ArgumentError
+      # on the server.
+      DATA_TYPES = %w[string integer decimal date date_time boolean bigint binary].freeze
+      DISPLAY_TYPES = %w[default html url email phone_number image].freeze
+      DATE_GRAINS = %w[raw millisecond second minute hour day month week quarter year].freeze
+      NUMERIC_DATA_TYPES = %w[integer decimal bigint].freeze
+      # semantic/measure.rb + measure/excludable.rb + measure/includable.rb
+      SNAPSHOT_TYPES = %w[beginning ending].freeze
+      EXCLUSION_TYPES = %w[exclude exclude_all_except exclude_all].freeze
+      EXCLUSION_ENTITY_TYPES = %w[dimension table universe].freeze
+      EXCLUSION_FILTER_TYPES = %w[ignore apply only].freeze
+      # semantic/partition.rb + semantic/parseable_date.rb
+      PARTITION_PREDICATES = %w[between greater_than greater_than_or_equal_to less_than less_than_or_equal_to].freeze
+      DYNAMIC_DATE = /(\d{1,3})([hdwmqy])/i
+      # semantic/join_def.rb enums — note: no many_to_many.
+      JOIN_TYPES = %w[inner left right].freeze
+      # semantic/expression.rb:17 — the server accepts any word(...) call.
+      MEASURE_SQL_FORMAT = /\A.*\w+\(.*\).*\z/i
+
+      private
+
+      # ---- datasources.yml (semantic/datasource.rb) ----
+
+      def audit_datasource_definitions
+        failures = []
+        seen_names = {}
+
+        datasources.each do |key, config|
+          unless config.is_a?(Hash)
+            failures << {file: "datasources.yml", message: "Datasource '#{key}' must be a mapping"}
+            next
+          end
+
+          adapter = config["adapter"].to_s.downcase.strip
+          if adapter.empty?
+            failures << {file: "datasources.yml", message: "Datasource '#{key}' missing required 'adapter'"}
+          elsif !DWH.adapter?(adapter.to_sym)
+            failures << {
+              file: "datasources.yml",
+              message: "Datasource '#{key}' has unknown adapter '#{adapter}' (known: #{DWH.adapters.keys.join(", ")})"
+            }
+          end
+
+          name = config["name"].to_s.downcase.strip
+          next if name.empty?
+
+          if seen_names[name]
+            failures << {
+              file: "datasources.yml",
+              message: "Datasource '#{key}' duplicates the name '#{config["name"]}' used by '#{seen_names[name]}'"
+            }
+          else
+            seen_names[name] = key
+          end
+        end
+
+        failures
+      end
+
+      # ---- fields (semantic/field.rb, semantic/measure.rb) ----
+
+      def validate_field_semantics(field, file, failures, meta)
+        name = field["name"]
+
+        unless FIELD_TYPES.include?(field["type"].to_s.downcase.strip)
+          failures << {
+            file: file,
+            message: "Field '#{name}' must have type: dimension or measure (the deployer dispatches on this key)"
+          }
+        end
+
+        validate_field_enums(name, field, file, failures)
+        validate_measure_rules(name, field, file, failures)
+        validate_expression_semantics(name, field, file, failures, meta)
+      end
+
+      def validate_field_enums(name, field, file, failures)
+        data_type = field["data_type"].to_s.strip
+        if data_type.empty?
+          failures << {file: file, message: "Field '#{name}' missing required 'data_type' (one of: #{DATA_TYPES.join(", ")})"}
+        elsif !DATA_TYPES.include?(data_type)
+          failures << {
+            file: file,
+            message: "Field '#{name}' has invalid data_type '#{data_type}' (expected one of: #{DATA_TYPES.join(", ")})"
+          }
+        end
+
+        if field.key?("display_type") && !DISPLAY_TYPES.include?(field["display_type"].to_s)
+          failures << {
+            file: file,
+            message: "Field '#{name}' has invalid display_type '#{field["display_type"]}' (expected one of: #{DISPLAY_TYPES.join(", ")})"
+          }
+        end
+
+        invalid_grains = Array(field["grains"]).map(&:to_s) - DATE_GRAINS
+        if invalid_grains.any?
+          failures << {file: file, message: "Field '#{name}' grains contains invalid values: #{invalid_grains.join(", ")}"}
+        end
+      end
+
+      def validate_measure_rules(name, field, file, failures)
+        if field.key?("snapshot") && !SNAPSHOT_TYPES.include?(field["snapshot"].to_s)
+          failures << {
+            file: file,
+            message: "Field '#{name}' has invalid snapshot '#{field["snapshot"]}' (expected beginning or ending)"
+          }
+        end
+
+        exclusion_type = field["exclusion_type"]
+        if exclusion_type && !EXCLUSION_TYPES.include?(exclusion_type.to_s)
+          failures << {
+            file: file,
+            message: "Field '#{name}' has invalid exclusion_type '#{exclusion_type}' (expected one of: #{EXCLUSION_TYPES.join(", ")})"
+          }
+        end
+
+        exclusions = Array(field["exclusions"])
+        if exclusion_type.to_s == "exclude_all" && exclusions.any?
+          failures << {file: file, message: "Field '#{name}' exclusions should be empty when exclusion_type is exclude_all"}
+        end
+
+        exclusions.each_with_index do |rule, idx|
+          unless rule.is_a?(Hash)
+            failures << {file: file, message: "Field '#{name}' exclusion at index #{idx} must be a mapping"}
+            next
+          end
+
+          unless EXCLUSION_ENTITY_TYPES.include?(rule["type"].to_s)
+            failures << {
+              file: file,
+              message: "Field '#{name}' exclusion type should be one of: #{EXCLUSION_ENTITY_TYPES.join(", ")}"
+            }
+          end
+          unless EXCLUSION_FILTER_TYPES.include?(rule["filter"].to_s)
+            failures << {
+              file: file,
+              message: "Field '#{name}' exclusion filter should be one of: #{EXCLUSION_FILTER_TYPES.join(", ")}"
+            }
+          end
+          if Array(rule["entities"]).empty?
+            failures << {file: file, message: "Field '#{name}' exclusion must list at least one entity"}
+          end
+        end
+
+        inclusions = field["inclusions"]
+        if inclusions.is_a?(Hash)
+          unless EXCLUSION_FILTER_TYPES.include?(inclusions["filter"].to_s)
+            failures << {
+              file: file,
+              message: "Field '#{name}' inclusions filter should be one of: #{EXCLUSION_FILTER_TYPES.join(", ")}"
+            }
+          end
+          if inclusions["aggregation"].to_s.strip.empty?
+            failures << {file: file, message: "Field '#{name}' inclusions missing 'aggregation'"}
+          end
+          if Array(inclusions["dimensions"]).empty?
+            failures << {file: file, message: "Field '#{name}' inclusions must list at least one dimension"}
+          end
+        elsif !inclusions.nil?
+          failures << {file: file, message: "Field '#{name}' inclusions must be a mapping"}
+        end
+      end
+
+      # ---- expressions (semantic/expression.rb, expression/references.rb) ----
+
+      def validate_expression_semantics(name, field, file, failures, meta)
+        sql = expression_sql(field["expression"])
+        return unless sql
+
+        begin
+          parsed = Sql::ExpressionParser.new(sql, reserved: meta[:reserved], aggregates: meta[:aggregates])
+        rescue => e
+          failures << {file: file, message: "Field '#{name}': expression could not be parsed: #{e.message}"}
+          return
+        end
+
+        dimension = field["type"].to_s.downcase.strip == "dimension"
+
+        # The incident this file exists for: expression.rb:14 requires a
+        # dimension's SQL to parse to at least one column token.
+        if dimension && parsed.columns.empty?
+          failures << {
+            file: file,
+            message: "Field '#{name}': dimensions should reference a table column " \
+              "(literals, reserved words and [Field] references alone don't count; quote a column whose name is a reserved word)"
+          }
+        end
+
+        # expression.rb:17 — skipped server-side when column_refs is empty
+        # (count(*)-style measures).
+        if !dimension && parsed.columns.any? && !sql.match?(MEASURE_SQL_FORMAT)
+          failures << {file: file, message: "Field '#{name}': measure should have an aggregation function"}
+        end
+
+        validate_reference_resolution(name, dimension, parsed, file, failures)
+      end
+
+      def validate_reference_resolution(name, dimension, parsed, file, failures)
+        fields = project_semantic_index[:fields]
+        measure_refs = parsed.measure_refs.dup
+
+        parsed.measure_refs.each do |ref|
+          unless (fields[ref] || []).include?("measure")
+            failures << {file: file, message: "Field '#{name}': [#{ref}]@m measure was not found in the project"}
+          end
+        end
+
+        parsed.dimension_refs.each do |ref|
+          unless (fields[ref] || []).include?("dimension")
+            failures << {file: file, message: "Field '#{name}': [#{ref}]@d dimension was not found in the project"}
+          end
+        end
+
+        parsed.field_refs.each do |ref|
+          types = fields[ref]
+          if types.nil?
+            failures << {file: file, message: "Field '#{name}': [#{ref}] field was not found in the project"}
+          elsif types.size > 1
+            # references.rb:97
+            failures << {
+              file: file,
+              message: "Field '#{name}': [#{ref}] matched multiple fields. Use @m or @d to specify the field further."
+            }
+          elsif types.include?("measure")
+            measure_refs << ref
+          end
+        end
+
+        # references.rb:127-131
+        if dimension && measure_refs.any?
+          failures << {
+            file: file,
+            message: "Field '#{name}': dimensions cannot reference measures. These are measures: #{measure_refs.join(", ")}"
+          }
+        end
+      end
+
+      def expression_sql(expression)
+        sql = expression.is_a?(Hash) ? (expression["sql"] || expression[:sql]) : expression
+        sql if sql.is_a?(String) && !sql.strip.empty?
+      end
+
+      # ---- table-level: snapshots and partitions ----
+
+      def validate_table_semantics(content, file, failures)
+        validate_snapshot_semantics(content, file, failures)
+        validate_partition_semantics(content, file, failures)
+      end
+
+      def validate_snapshot_semantics(content, file, failures)
+        snap_name = content["snapshot"].to_s.downcase.strip
+
+        if snap_name.empty?
+          # expression.rb:39-43 — a snapshot measure only maps to snapshot tables.
+          Array(content["fields"]).each do |f|
+            next unless f.is_a?(Hash)
+            next unless SNAPSHOT_TYPES.include?(f["snapshot"].to_s)
+            next if f["type"].to_s.downcase.strip == "dimension"
+
+            failures << {
+              file: file,
+              message: "Field '#{f["name"]}' is a snapshot measure and can only be mapped to snapshot tables " \
+                "(add a table-level 'snapshot' key naming a date dimension)"
+            }
+          end
+          return
+        end
+
+        # deployer/handlers/table.rb:204 + table/snappable.rb:40-43
+        unless (project_semantic_index[:fields][snap_name] || []).include?("dimension")
+          failures << {file: file, message: "Snapshot dimension '#{content["snapshot"]}' was not found in the project"}
+          return
+        end
+
+        data_type = project_semantic_index[:dimension_data_types][snap_name].to_s
+        unless %w[date date_time].include?(data_type)
+          failures << {
+            file: file,
+            message: "Snapshot date '#{content["snapshot"]}' must be a date or date_time dimension (got '#{data_type}')"
+          }
+        end
+      end
+
+      def validate_partition_semantics(content, file, failures)
+        partitions = content["partition"] || content["partitions"]
+        return if partitions.nil?
+
+        unless partitions.is_a?(Array)
+          failures << {file: file, message: "'partitions' must be an array"}
+          return
+        end
+
+        partitions.each_with_index do |part, idx|
+          unless part.is_a?(Hash)
+            failures << {file: file, message: "Partition at index #{idx} must be a mapping"}
+            next
+          end
+
+          label = part["dimension"] || "index #{idx}"
+          dim_name = part["dimension"].to_s.downcase.strip
+          if dim_name.empty?
+            failures << {file: file, message: "Partition at index #{idx} missing 'dimension'"}
+          elsif !(project_semantic_index[:fields][dim_name] || []).include?("dimension")
+            failures << {file: file, message: "Partition dimension '#{part["dimension"]}' was not found in the project"}
+          end
+
+          predicate = part["predicate"]
+          if predicate && !PARTITION_PREDICATES.include?(predicate.to_s)
+            failures << {
+              file: file,
+              message: "Partition on '#{label}' has invalid predicate '#{predicate}' (expected one of: #{PARTITION_PREDICATES.join(", ")})"
+            }
+          end
+
+          validate_partition_values(part, dim_name, label, predicate, file, failures)
+        end
+      end
+
+      # semantic/partition.rb:15-18 + parseable_date.rb
+      def validate_partition_values(part, dim_name, label, predicate, file, failures)
+        data_type = project_semantic_index[:dimension_data_types][dim_name].to_s
+        values = [part["filter_value"]]
+        values << part["filter_value_end"] if predicate.to_s == "between"
+
+        values.each_with_index do |value, i|
+          key = i.zero? ? "filter_value" : "filter_value_end"
+
+          if value.to_s.strip.empty?
+            failures << {file: file, message: "Partition on '#{label}' missing '#{key}'"}
+          elsif NUMERIC_DATA_TYPES.include?(data_type) && !numeric?(value)
+            failures << {file: file, message: "Partition on '#{label}' #{key} '#{value}' is not a number"}
+          elsif %w[date date_time].include?(data_type) && !parseable_partition_date?(value)
+            failures << {
+              file: file,
+              message: "Partition on '#{label}' #{key} '#{value}' is not a dynamic date (like 28d, 6h, 1m) or a parseable date"
+            }
+          end
+        end
+      end
+
+      def numeric?(value)
+        Float(value)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      def parseable_partition_date?(value)
+        return true if value.is_a?(Date) || value.is_a?(Time)
+
+        s = value.to_s.strip
+        return true if DYNAMIC_DATE.match?(s)
+
+        DateTime.parse(s)
+        true
+      rescue ArgumentError, TypeError
+        false
+      end
+
+      # ---- relationships (semantic/join_def.rb, deployer/handlers/relationships.rb) ----
+
+      def validate_relationship_semantics(content, file, failures)
+        ds_key = resolve_datasource_value(content["datasource"])
+
+        content.each do |key, definition|
+          next if key == "datasource" || key == "imports"
+          next unless definition.is_a?(Hash)
+
+          sql = definition["sql"].to_s.downcase
+          # join_def.rb:70-77
+          if !sql.empty? && !(sql.match?(/left\./) && sql.match?(/right\./))
+            failures << {file: file, message: "Relationship '#{key}' join sql should be of the format left.column = right.column"}
+          end
+
+          if definition.key?("join") && !JOIN_TYPES.include?(definition["join"].to_s)
+            failures << {
+              file: file,
+              message: "Relationship '#{key}' has invalid join '#{definition["join"]}' (expected one of: #{JOIN_TYPES.join(", ")})"
+            }
+          end
+
+          validate_relationship_tables(key, definition, ds_key, file, failures)
+        end
+      end
+
+      def validate_relationship_tables(key, definition, ds_key, file, failures)
+        tables = project_semantic_index[:tables]
+        left = definition["left"].to_s.downcase.strip
+        right = definition["right"].to_s.downcase.strip
+
+        [["left", left], ["right", right]].each do |side, table_name|
+          next if table_name.empty?
+
+          table = tables[table_name]
+          if table.nil?
+            # deployer/handlers/relationships.rb:106-107
+            failures << {file: file, message: "Relationship '#{key}': #{side} table '#{definition[side]}' was not found in the project"}
+          elsif ds_key && (table_ds = resolve_datasource_value(table["datasource"])) && table_ds != ds_key
+            # join_def.rb:65-67
+            failures << {
+              file: file,
+              message: "Relationship '#{key}': #{side} table '#{definition[side]}' is not in datasource '#{ds_key}' (tables can only join within one datasource)"
+            }
+          end
+        end
+
+        return if left.empty? || right.empty?
+
+        # join_def.rb:79-83 — joins are bi-directional, so either order collides.
+        pair = [left, right].sort
+        if (existing = seen_join_pairs[pair])
+          failures << {
+            file: file,
+            message: "Relationship '#{key}': a join between '#{definition["left"]}' and '#{definition["right"]}' already exists (#{existing})"
+          }
+        else
+          seen_join_pairs[pair] = "#{file}: #{key}"
+        end
+      end
+
+      def seen_join_pairs
+        @seen_join_pairs ||= {}
+      end
+
+      # ---- shared infrastructure ----
+
+      # Name index of every table and field declared across the project's
+      # tbl.*.yml files, keyed by lowercased name (the server resolves
+      # references by lower(name), and the expression parser downcases its
+      # input, so lowercase keys line up on both sides).
+      def project_semantic_index
+        @project_semantic_index ||= begin
+          fields = {}
+          dimension_data_types = {}
+          tables = {}
+
+          Dir.glob("models/**/*.yml").each do |file|
+            next unless File.basename(file).start_with?("tbl.")
+
+            content = begin
+              Utils::YamlImportResolver.resolve(file, Dir.pwd)
+            rescue
+              next # unreadable files are reported by the structural checks
+            end
+            next unless content.is_a?(Hash)
+
+            table_name = content["name"].to_s.downcase.strip
+            unless table_name.empty?
+              tables[table_name] = {"datasource" => content["datasource"], "file" => file}
+            end
+
+            Array(content["fields"]).each do |f|
+              next unless f.is_a?(Hash) && f["name"]
+
+              # Mirror the deployer's dispatch: literal "dimension" or bust.
+              type = (f["type"].to_s.downcase.strip == "dimension") ? "dimension" : "measure"
+              name = f["name"].to_s.downcase.strip
+              entry = (fields[name] ||= [])
+              entry << type unless entry.include?(type)
+              dimension_data_types[name] = f["data_type"].to_s if type == "dimension"
+            end
+          end
+
+          {fields: fields, tables: tables, dimension_data_types: dimension_data_types}
+        end
+      end
+
+      # Reserved keywords + aggregate function names for the adapter behind a
+      # table's datasource — class-level data from the dwh gem, no connection.
+      # Unknown datasources/adapters fall back to the gem's base lists (the
+      # broken datasource reference itself is reported elsewhere).
+      def adapter_meta(ds_value)
+        @adapter_meta ||= {}
+        key = resolve_datasource_value(ds_value)
+        config = (key && (datasources[key] || datasources[key.to_s.downcase.strip])) || {}
+        sym = config["adapter"].to_s.downcase.strip.to_sym
+
+        @adapter_meta[sym] ||= if DWH.adapter?(sym)
+          klass = DWH.get_adapter(sym)
+          {reserved: klass.reserved_keywords, aggregates: klass.aggregate_functions}
+        else
+          {reserved: DWH.reserved_keywords, aggregates: DWH.aggregate_functions}
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require_relative "../terminal"
 require_relative "../credentials"
 require_relative "../output"
 require_relative "../helpers/datasource_helper"
+require_relative "../helpers/semantic_audit_checks"
 require_relative "../agent_mode"
 require_relative "../utils/yaml_import_resolver"
 require_relative "../utils/import_manager"
@@ -20,12 +21,13 @@ module Strata
         include Terminal
         include Output
         include DatasourceHelper
+        include SemanticAuditChecks
         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
+        RELATIONSHIP_CARDINALITIES = %w[one_to_one one_to_many many_to_one].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
@@ -33,6 +35,7 @@ module Strata
           exclusions inclusions extended_blend_group synonyms expression tags
         ].freeze
         ALLOWED_EXPRESSION_KEYS = %w[sql array lookup primary_key].freeze
+        STRAY_SCRIPT_EXTENSIONS = %w[.rb .py .sh .ipynb].freeze
         EXPRESSION_BOOLEAN_KEYS = %w[array lookup primary_key].freeze
 
         # Set default command so `strata audit` still works as `strata audit all`
@@ -45,6 +48,7 @@ module Strata
           results[:models] = run_check("Checking model definitions") { audit_models }
           results[:connections] = run_check("Checking data source connections") { audit_connections }
 
+          warn_stray_files
           report_results(results)
         end
 
@@ -77,6 +81,17 @@ module Strata
           end
         end
 
+        # A Strata project holds YAML, not scripts. Agents sometimes leave scratch
+        # validators behind; warn, don't fail — a helper script is the user's call.
+        def warn_stray_files
+          strays = Dir.glob("models/**/*").select { File.file?(it) && File.extname(it) != ".yml" }
+          strays += Dir.glob("*").select { File.file?(it) && STRAY_SCRIPT_EXTENSIONS.include?(File.extname(it)) }
+          return if strays.empty?
+
+          print_warning("\n  Unexpected files — models belong in YAML; delete these or move them out of the project:")
+          strays.sort.each { print_warning("    #{it}") }
+        end
+
         def run_check(message)
           failures = []
           with_spinner(message) do
@@ -107,7 +122,7 @@ module Strata
         end
 
         def audit_models
-          failures = []
+          failures = audit_datasource_definitions
           Dir.glob("models/**/*.yml").each do |file|
             audit_imports(file, failures)
             audit_model_file(file, failures)
@@ -154,13 +169,15 @@ 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)
+          validate_table_fields(content["fields"], file, failures, adapter_meta(content["datasource"]))
+          validate_table_semantics(content, file, failures)
         end
 
         def validate_relationship_model(content, file, failures)
           validate_required_keys(content, file, REQUIRED_KEYS_FOR_RELATIONSHIP_MODEL, failures)
           validate_datasource_reference(content, file, failures)
           validate_relationship_definitions(content, file, failures)
+          validate_relationship_semantics(content, file, failures)
         end
 
         def validate_datasource_reference(content, file, failures)
@@ -180,7 +197,7 @@ module Strata
           failures << {file: file, message: "Missing required keys: #{missing.join(", ")}"} if missing.any?
         end
 
-        def validate_table_fields(fields, file, failures)
+        def validate_table_fields(fields, file, failures, adapter_meta)
           unless fields.is_a?(Array)
             failures << {file: file, message: "'fields' must be an array"}
             return
@@ -197,11 +214,11 @@ module Strata
               next
             end
 
-            validate_field_definition(field, file, idx, failures)
+            validate_field_definition(field, file, idx, failures, adapter_meta)
           end
         end
 
-        def validate_field_definition(field, file, idx, failures)
+        def validate_field_definition(field, file, idx, failures, adapter_meta)
           field_name = field["name"] || "index #{idx}"
 
           unknown_keys = field.keys.map(&:to_s) - ALLOWED_FIELD_KEYS
@@ -213,6 +230,7 @@ module Strata
           end
 
           validate_field_expression(field_name, field["expression"], file, failures)
+          validate_field_semantics(field, file, failures, adapter_meta)
 
           return unless field.key?("format")
 

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

@@ -93,7 +93,6 @@ module Strata
         end
 
         def confirm_branch_deletion(branch_id)
-          prompt = TTY::Prompt.new
           answer = prompt.ask("Type '#{branch_id}' to delete this branch from Strata:")
           return true if answer.to_s == branch_id
 

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

@@ -7,6 +7,7 @@ require_relative "../output"
 require_relative "../utils/git"
 require "tty-prompt"
 require_relative "../helpers/datasource_helper"
+require_relative "../helpers/prompts"
 require_relative "../helpers/description_helper"
 require_relative "../agent_mode"
 
@@ -62,8 +63,6 @@ module Strata
         desc "add [ADAPTER]", "Add a new datasource interactively"
         long_desc_from_file "datasource/add"
         def add(adapter_name = nil)
-          prompt = TTY::Prompt.new
-
           if adapter_name && !DWH.adapters.keys.map(&:to_s).include?(adapter_name)
             say "Error: '#{adapter_name}' is not a supported adapter", :red
             say "Supported adapters: #{DWH.adapters.keys.join(", ")}", :yellow
@@ -132,6 +131,11 @@ module Strata
           end
 
           say "\n✔ Datasource '#{ds_key}' is ready!", :green
+
+          # 'strata init' runs this command inline and prints its own next steps after.
+          return if options["from_init"] || agent_mode?
+
+          say "\n#{Prompts.build_model_next_steps}", :cyan
         end
 
         desc "auth DS_KEY", "Set credentials for the given datasource key (DS_KEY)."
@@ -182,8 +186,7 @@ module Strata
         method_option :catalog, aliases: "c", type: :string, desc: "Change the catalog from the configured one."
         method_option :schema, aliases: "s", type: :string, desc: "Change the schema from the configured one."
         def tables(ds_key = nil)
-          prompt = TTY::Prompt.new
-          ds_key = resolve_datasource(ds_key, prompt: prompt)
+          ds_key = resolve_datasource(ds_key)
           return unless ds_key
 
           adapter = create_adapter(ds_key)