strata-cli 0.1.0.beta

data/lib/strata/cli/ui/autocomplete.rb

@@ -0,0 +1,93 @@
+require "tty-prompt"
+require_relative "../helpers/table_filter"
+
+module Strata
+  module CLI
+    # Reusable autocomplete component for fuzzy search selection.
+    # Works with any collection of items - tables, models, dimensions, etc.
+    class Autocomplete
+      attr_reader :prompt
+
+      def initialize(prompt: TTY::Prompt.new)
+        @prompt = prompt
+      end
+
+      # Select an item with fuzzy search filtering
+      # @param message [String] The prompt message
+      # @param items [Array<String>] Items to search through
+      # @param per_page [Integer] Number of items to show at once
+      # @param display_transform [Proc, nil] Optional proc to transform display names
+      # @param default_filter [String, nil] Optional initial filter to pre-apply
+      # @return [String, nil] Selected item or nil if cancelled
+      def select(message, items, per_page: 10, display_transform: nil, default_filter: nil)
+        return nil if items.empty?
+
+        # Create display mapping if transform provided
+        display_map = {}
+        display_items = if display_transform
+          items.map do |item|
+            display_name = display_transform.call(item)
+            display_map[display_name] = item
+            display_name
+          end
+        else
+          items
+        end
+
+        # Pre-filter items if default_filter provided
+        filtered_items = display_items
+        if default_filter && !default_filter.empty?
+          pattern = Regexp.new(Regexp.escape(default_filter), Regexp::IGNORECASE)
+          filtered_items = display_items.select { |item| item.match?(pattern) }
+
+          # If filter matches exactly one item, still show all but highlight the match
+          # If filter matches some items, show those
+          # If no matches, show all items
+          filtered_items = display_items if filtered_items.empty?
+        end
+
+        # Build the prompt message with filter hint
+        full_message = if default_filter && !default_filter.empty? && filtered_items.length < display_items.length
+          "#{message} (filtered by '#{default_filter}'. Type in characters to apply different filter)"
+        else
+          message
+        end
+
+        selected_display = prompt.select(
+          full_message,
+          filtered_items,
+          filter: true,
+          per_page: per_page,
+          show_help: :always,
+          help: "(Type to filter, ↑/↓ to navigate)"
+        )
+
+        return nil if selected_display.nil?
+
+        # Map back to original item if transform was used
+        display_transform ? display_map[selected_display] : selected_display
+      rescue TTY::Reader::InputInterrupt
+        nil
+      end
+
+      # Multi-select with fuzzy search
+      # @param message [String] The prompt message
+      # @param items [Array<String>] Items to search through
+      # @return [Array<String>] Selected items
+      def multi_select(message, items, per_page: 10)
+        return [] if items.empty?
+
+        prompt.multi_select(
+          message,
+          items,
+          filter: true,
+          per_page: per_page,
+          show_help: :always,
+          help: "(Type to filter, Space to select, Enter to confirm)"
+        )
+      rescue TTY::Reader::InputInterrupt
+        []
+      end
+    end
+  end
+end

data/lib/strata/cli/ui/field_editor.rb

@@ -0,0 +1,215 @@
+require "tty-prompt"
+require "tty-table"
+require "pastel"
+require_relative "../helpers/color_helper"
+
+module Strata
+  module CLI
+    # Interactive field editor with row-by-row navigation.
+    # Displays a table of AI-generated fields and allows inline editing.
+    class FieldEditor
+      include Terminal
+
+      attr_reader :fields, :prompt, :pastel, :model_context
+
+      # @param fields [Array<Hash>] Fields from AI with :name, :description, :expression, :schema_type, :data_type
+      # @param table_context [Hash, nil] Optional context with :table_name, :columns, :datasource for prompt mode
+      # @param model_context [Hash, nil] Optional model metadata with :description
+      def initialize(fields, prompt: TTY::Prompt.new, table_context: nil, model_context: nil)
+        @fields = fields.map { |f| f.merge(skipped: false) }
+        @prompt = prompt
+        @pastel = Pastel.new
+        @selected_index = 0
+        @model_context = model_context || {description: ""}
+        @table_context = table_context
+      end
+
+      # Run the interactive editor
+      # @return [Array<Hash>, nil] Confirmed fields or nil if cancelled
+      def run
+        loop do
+          clear_screen
+          display_table
+          display_help
+          show_cursor
+
+          key = prompt.reader.read_keypress
+
+          case key
+          when "\e[A", "k" # Up arrow or k
+            @selected_index = [@selected_index - 1, 0].max
+          when "\e[B", "j" # Down arrow or j
+            @selected_index = [@selected_index + 1, @fields.length - 1].min
+          when "\r", "\n" # Enter
+            handle_edit
+          when "s", "S"
+            toggle_skip
+          when "p", "P"
+            handle_prompt_mode
+          when "c", "C"
+            if prompt.yes?("Confirm and generate model file?")
+              show_cursor
+              return {fields: active_fields, model_context: @model_context}
+            end
+          when "q", "Q", "\e" # q or Escape
+            if prompt.yes?("Quit without saving?")
+              show_cursor
+              return nil
+            end
+          end
+        end
+      end
+
+      private
+
+      def clear_screen
+        # Hide cursor, move to home, clear screen, then show cursor after render
+        # This reduces perceived flicker
+        print "\e[?25l"  # Hide cursor
+        print "\e[H"     # Move to home (top-left)
+        print "\e[2J"    # Clear screen
+      end
+
+      def show_cursor
+        print "\e[?25h"  # Show cursor
+      end
+
+      def display_table
+        colors = ColorHelper
+        puts colors.highlight("\n  Field Editor - Review & Edit Generated Fields\n")
+
+        rows = @fields.each_with_index.map do |field, idx|
+          indicator = (idx == @selected_index) ? colors.selected("❯") : " "
+          status = field[:skipped] ? colors.disabled("[SKIP]") : ""
+
+          name_cell = field[:skipped] ? colors.disabled(field[:name]) : field[:name]
+          desc_cell = if field[:skipped]
+            colors.disabled(truncate(field[:description],
+              25))
+          else
+            truncate(field[:description], 25)
+          end
+          expr_cell = field[:skipped] ? colors.disabled(field[:expression]) : field[:expression]
+
+          [
+            "#{indicator} #{status}",
+            name_cell,
+            desc_cell,
+            expr_cell
+          ]
+        end
+
+        table = TTY::Table.new(
+          header: [" ", "Field Name", "Description", "Expression"],
+          rows: rows
+        )
+
+        puts table.render(:unicode, padding: [0, 1]) do |renderer|
+          renderer.border.style = :bright_cyan
+        end
+      end
+
+      def display_help
+        colors = ColorHelper
+        puts ""
+        puts "  #{colors.info("↑/↓")} Navigate  " \
+             "#{colors.success("[Enter]")} Edit  " \
+             "#{colors.warning("[S]")}kip  " \
+             "#{colors.primary("[P]")}rompt  " \
+             "#{colors.secondary("[C]")}onfirm  " \
+             "#{colors.error("[Q/Esc]")}uit"
+        puts ""
+      end
+
+      def handle_edit
+        edit_current_field
+      end
+
+      def edit_current_field
+        field = @fields[@selected_index]
+        colors = ColorHelper
+
+        puts colors.highlight("\n  Editing: #{field[:name]}\n")
+        puts colors.dim("  (Press Ctrl+C or type 'back' to go back without saving)\n")
+
+        begin
+          field[:name] = prompt.ask("  Field Name:", default: field[:name])
+          return if field[:name] == "back"
+
+          field[:description] = prompt.ask("  Description:", default: field[:description])
+          return if field[:description] == "back"
+
+          field[:expression] = prompt.ask("  Expression:", default: field[:expression])
+          return if field[:expression] == "back"
+
+          field[:schema_type] = prompt.select("  Type:", %w[dimension measure], default: field[:schema_type])
+        rescue TTY::Reader::InputInterrupt
+          # User pressed Ctrl+C, go back without saving
+          nil
+        end
+      end
+
+      def toggle_skip
+        @fields[@selected_index][:skipped] = !@fields[@selected_index][:skipped]
+      end
+
+      def active_fields
+        @fields.reject { |f| f[:skipped] }
+      end
+
+      def truncate(str, length)
+        return "" if str.nil?
+
+        (str.length > length) ? "#{str[0...length - 2]}.." : str
+      end
+
+      def handle_prompt_mode
+        require_relative "../ai/services/model_generator"
+        require_relative "../terminal"
+        generator = AI::Services::ModelGenerator.new
+
+        colors = ColorHelper
+
+        unless generator.ai_available?
+          puts colors.warning("\n  AI is not available. Configure AI in .strata file.")
+          sleep 1.5
+          return
+        end
+
+        unless @table_context
+          puts colors.warning("\n  Prompt mode requires table context.")
+          sleep 1.5
+          return
+        end
+
+        print "\n"
+        user_prompt = prompt.ask("  Enter your prompt to regenerate/modify the table:")
+        return if user_prompt.nil? || user_prompt.strip.empty?
+
+        begin
+          new_fields = with_spinner("Regenerating fields with AI") do
+            generator.call_with_prompt(
+              table_name: @table_context[:table_name],
+              columns: @table_context[:columns],
+              datasource: @table_context[:datasource],
+              user_prompt: user_prompt,
+              current_fields: active_fields
+            )
+          end
+
+          if new_fields && !new_fields.empty?
+            @fields = new_fields.map { |f| f.merge(skipped: false) }
+            @selected_index = 0
+            # No message needed - table will refresh and show new fields
+          else
+            puts colors.warning("  No changes - keeping current fields")
+            sleep 1
+          end
+        rescue => e
+          puts colors.error("\n  Error: #{e.message}")
+          sleep 2
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/utils/archive.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "rubygems/package"
+require "fileutils"
+require "tempfile"
+require "pathname"
+require "securerandom"
+require "yaml"
+require_relative "yaml_import_resolver"
+require_relative "import_manager"
+
+module Strata
+  module CLI
+    module Utils
+      module Archive
+        module_function
+
+        def create(project_path, files_to_include: nil)
+          if files_to_include
+            # Use provided file list, but ensure they exist and are yml files
+            files = files_to_include.select do |file_path|
+              File.file?(file_path) && file_path.end_with?(".yml", ".yaml")
+            end
+            # Ensure required files are included if they exist
+            files = ensure_required_files(files, project_path)
+          else
+            # Collect all yml files if no list provided
+            files = collect_yml_files(project_path)
+          end
+          files = exclude_secrets(files)
+          inlined_files = process_imports(files, project_path)
+          build_archive(files, project_path, inlined_files)
+        end
+
+        private_class_method def collect_yml_files(project_path)
+          Dir.glob(File.join(project_path, "**", "*.yml")).select do |file_path|
+            File.file?(file_path)
+          end
+        end
+
+        private_class_method def ensure_required_files(files, project_path)
+          required_files = [
+            File.join(project_path, "project.yml"),
+            File.join(project_path, "datasources.yml")
+          ]
+
+          required_files.each do |required_file|
+            if File.exist?(required_file) && !files.include?(required_file)
+              files << required_file
+            end
+          end
+
+          # Always include all test files
+          test_files = Dir.glob(File.join(project_path, "tests", "*.{yml,yaml}"))
+          test_files.each do |test_file|
+            files << test_file unless files.include?(test_file)
+          end
+
+          files
+        end
+
+        private_class_method def exclude_secrets(files)
+          files.reject do |file_path|
+            file_path.include?(".strata") || file_path.include?("/.strata")
+          end
+        end
+
+        private_class_method def process_imports(files, project_path)
+          inlined_files = {}
+          files.each do |file_path|
+            next unless file_path.end_with?(".yml", ".yaml")
+            next unless file_path.start_with?(project_path)
+
+            # Only process table files (tbl.*.yml) through YamlImportResolver
+            # Other files (datasources.yml, rel.*.yml, etc.) don't have imports/fields structure
+            filename = File.basename(file_path)
+            next unless filename.start_with?("tbl.")
+
+            begin
+              inlined_content = YamlImportResolver.resolve(file_path, project_path)
+              inlined_files[file_path] = inlined_content
+            rescue Strata::ImportError
+              # If import resolution fails, use original file
+              # Error will be caught during archive creation or audit
+            end
+          end
+
+          inlined_files
+        end
+
+        def build_archive(files, project_path, inlined_files = {})
+          archive_file = archive_path
+
+          File.open(archive_file, "wb") do |file|
+            Zlib::GzipWriter.open(file) do |gz|
+              Gem::Package::TarWriter.new(gz) do |tar|
+                files.each do |file_path|
+                  add_file_to_tar(tar, file_path, project_path, inlined_files)
+                end
+              end
+            end
+          end
+
+          archive_file
+        end
+
+        private_class_method def add_file_to_tar(tar, file_path, project_path, inlined_files = {})
+          relative_path = file_path.sub("#{project_path}/", "")
+
+          if inlined_files[file_path]
+            content = YAML.dump(inlined_files[file_path])
+            size = content.bytesize
+            mode = 0o644
+
+            tar.add_file_simple(relative_path, mode, size) do |tar_file|
+              tar_file.write(content)
+            end
+          else
+            mode = File.stat(file_path).mode
+            size = File.size(file_path)
+
+            tar.add_file_simple(relative_path, mode, size) do |tar_file|
+              File.open(file_path, "rb") { |f| tar_file.write(f.read) }
+            end
+          end
+        end
+
+        private_class_method def archive_path
+          timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+          random_suffix = SecureRandom.hex(8)
+          File.join(Dir.tmpdir, "deploy-#{timestamp}-#{random_suffix}.tar.gz")
+        end
+      end
+    end
+  end
+end