strata-cli 0.1.0.beta

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

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require_relative "../guard"
+require_relative "../terminal"
+require_relative "../helpers/color_helper"
+require_relative "../helpers/project_helper"
+require_relative "../helpers/description_helper"
+require_relative "../api/client"
+require_relative "../utils"
+require_relative "../utils/archive"
+require_relative "../utils/git"
+require_relative "../utils/deployment_monitor"
+require_relative "../utils/import_manager"
+require "tty-prompt"
+require "yaml"
+require "fileutils"
+
+module Strata
+  module CLI
+    module SubCommands
+      class Deploy < Thor
+        include Guard
+        include Terminal
+        extend Helpers::DescriptionHelper
+
+        default_command :deploy
+
+        class_option :environment, aliases: ["e"], type: :string
+        class_option :skip_audit, type: :boolean, default: false
+        class_option :yes, type: :boolean, default: false
+        class_option :force, aliases: ["f"], type: :boolean, default: false
+
+        desc "deploy", "Deploy project to Strata server for the current branch"
+        long_desc_from_file "deploy/deploy"
+        def deploy
+          config = load_deployment_configuration
+          validate_deployment_configuration(config)
+          run_pre_deploy_checks unless options[:skip_audit]
+          refreshed_imports = refresh_external_imports # Auto-refresh external imports before checking for changes
+
+          branch_id = determine_deployment_branch
+          run_git_status_checks(branch_id)
+          confirm_production_deploy(branch_id, config) unless options[:yes]
+
+          # Get last successful deployment to determine what files changed
+          last_deployment_commit = get_last_successful_deployment_commit(config, branch_id)
+
+          # Check local file changes
+          local_file_changes = if last_deployment_commit && Utils::Git.git_repo?
+            Utils::Git.changed_file_paths_since(last_deployment_commit)
+          else
+            []
+          end
+          metadata = prepare_deployment_metadata(last_deployment_commit)
+
+          # If only external imports changed, generate synthetic commit identifier
+          if refreshed_imports.any? && local_file_changes.empty?
+            import_commit_hash = Utils::ImportManager.generate_import_commit_hash(project_path)
+            say "\nExternal imports change found. Proceeding with deployment", ColorHelper.info
+            metadata[:commit] = "imports-#{import_commit_hash}"
+            metadata[:commit_message] = "External imports updated: #{refreshed_imports.map { |c| File.basename(c[:source]) }.join(", ")}"
+          end
+
+          archive_path = create_and_upload_archive(last_deployment_commit, refreshed_imports: refreshed_imports)
+
+          env_display = options[:environment] ? " (#{options[:environment]} environment)" : ""
+          server_info = config["server"] ? " (#{config["server"]})" : ""
+          say "\nDeploying to branch '#{branch_id}' on Strata server#{env_display}#{server_info}\n", ColorHelper.info
+
+          deployment = submit_deployment(config, branch_id, archive_path, metadata)
+
+          # Start monitoring deployment progress
+          monitor_deployment(config, branch_id, deployment)
+        end
+
+        desc "status", "Show current deployment status of the current branch"
+        long_desc_from_file "deploy/status"
+        def status
+          config = load_deployment_configuration
+          validate_deployment_configuration(config)
+
+          branch_id = determine_deployment_branch
+          client = API::Client.new(config["server"], config["api_key"])
+          deployment = client.latest_deployment(config["project_id"], branch_id)
+
+          unless deployment
+            say "No deployments found for branch '#{branch_id}'.\n", ColorHelper.info
+            return
+          end
+
+          deployment_id = deployment["id"]
+          has_tests = test_files_exist?
+          monitor = Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id, has_tests: has_tests)
+
+          # Show current status
+          result = monitor.display_status
+
+          # Continue monitoring if deployment is in progress, or if tests are expected but not yet available
+          should_continue_monitoring = if result && !["succeeded", "failed"].include?(result["status"])
+            true
+          elsif result && result["status"] == "succeeded" && result["stage"] == "finished"
+            # Check if tests are expected but not yet available
+            latest_test_run = result["latest_test_run"] || result[:latest_test_run]
+            has_tests && latest_test_run.nil?
+          else
+            false
+          end
+
+          monitor.start(skip_initial_display: true) if should_continue_monitoring
+        end
+
+        private
+
+        def project_path
+          @project_path ||= Dir.pwd
+        end
+
+        def load_deployment_configuration
+          env = options[:environment]
+          CLI.config.get_for_environment(env)
+        end
+
+        def validate_deployment_configuration(config)
+          ensure_api_key(config)
+          validate_server_url(config)
+          ensure_git_url_populated
+          ensure_project_id(config)
+        end
+
+        def ensure_api_key(config)
+          return if config["api_key"] && !config["api_key"].to_s.strip.empty? && config["api_key"] != "YOUR_STRATA_API_KEY"
+
+          config["api_key"] = collect_api_key_interactively
+        end
+
+        def validate_server_url(config)
+          server_url = config["server"]
+          return if server_url && !server_url.to_s.strip.empty?
+
+          env_msg = options[:environment] ? " (or in '#{options[:environment]}' environment section)" : ""
+          say "\nServer URL not configured in project.yml#{env_msg}", :yellow
+          say "Please add or update the 'server' field in project.yml and try again.\n", :white
+          exit(1)
+        end
+
+        def ensure_git_url_populated
+          return unless Helpers::ProjectHelper.persist_git_url_if_missing
+
+          CLI.config.reload!
+
+          if Utils::Git.git_repo?
+            Utils::Git.commit_file(
+              Configuration::PROJECT_CONFIG_FILE,
+              "[Strata-CLI] Auto-populate git URL from remote",
+              project_path
+            )
+          end
+        end
+
+        def ensure_project_id(config)
+          return if config["project_id"] && !config["project_id"].to_s.strip.empty?
+
+          project_id = create_project_on_server(config)
+          config["project_id"] = project_id
+          persist_project_id(project_id)
+        end
+
+        def collect_api_key_interactively
+          prompt = TTY::Prompt.new
+
+          say "\nAPI key not found in .strata file", :yellow
+          say "\nTo deploy to Strata, you need an API key.\nYou can get your API key from:", :white
+          say "  • Your Strata server dashboard (Settings → API Keys)\n  • Your Strata administrator\n", :cyan
+
+          api_key = prompt.mask("Enter your Strata API key:") do |q|
+            q.required true
+            q.validate(/\S+/, "API key cannot be empty")
+          end
+
+          # Save API key to .strata file
+          with_spinner("Saving API key to .strata file") do
+            save_api_key_to_strata(api_key)
+          end
+
+          api_key
+        end
+
+        def save_api_key_to_strata(api_key)
+          strata_file = Configuration::STRATA_CONFIG_FILE
+
+          # Read existing content if file exists
+          existing_content = File.exist?(strata_file) ? File.read(strata_file) : ""
+
+          begin
+            if /^api_key:\s*.+$/m.match?(existing_content)
+              updated_content = existing_content.gsub(/^(\s*)api_key:\s*.+$/, "\\1api_key: #{api_key}")
+              File.write(strata_file, updated_content)
+            else
+              File.open(strata_file, "a") do |f|
+                f.puts "\n" unless existing_content.empty? || existing_content.end_with?("\n")
+                f.puts "api_key: #{api_key}"
+              end
+            end
+
+            # Set restrictive permissions (read/write for owner only)
+            File.chmod(0o600, strata_file) if File.exist?(strata_file)
+
+            # Reload config to pick up the new API key
+            CLI.config.reload!
+          rescue Errno::EACCES => e
+            raise Strata::CommandError, "Permission denied writing to #{strata_file}: #{e.message}"
+          rescue Errno::ENOSPC => e
+            raise Strata::CommandError, "Disk full: #{e.message}"
+          rescue => e
+            raise Strata::CommandError, "Failed to write API key to #{strata_file}: #{e.message}"
+          end
+        end
+
+        def handle_missing_deployment_config(config, key)
+          raise Strata::CommandError, "Missing required configuration: #{key}. Check your project.yml file."
+        end
+
+        def run_pre_deploy_checks
+          require_relative "../sub_commands/audit"
+          with_spinner("Running pre-deploy audit checks") do
+            SubCommands::Audit.new.all
+          end
+        rescue SystemExit => e
+          raise Strata::CommandError, "Audit checks failed. Fix errors before deploying." if e.status != 0
+        end
+
+        def run_git_status_checks(branch_name)
+          return unless Utils::Git.git_repo?
+
+          with_spinner("Checking git repository status") do
+            # Check for uncommitted changes
+            if Utils::Git.uncommitted_changes?
+              raise Strata::CommandError, "You have uncommitted changes. Please commit or stash them before deploying."
+            end
+          end
+
+          # Fetch from remote
+          with_spinner("Fetching latest changes from remote") do
+            Utils::Git.fetch_branch(branch_name)
+          end
+
+          # Check commit status
+          commit_status = Utils::Git.check_commit_status(branch_name)
+          case commit_status[:status]
+          when :behind
+            raise Strata::CommandError, "Your local branch is behind remote. Please pull latest changes before deploying."
+          when :diverged
+            raise Strata::CommandError, "Your local branch has diverged from remote. Please sync your branch before deploying."
+          when :ahead, :same
+            # Status is already shown via spinner, no need for additional message
+          end
+        end
+
+        def determine_deployment_branch
+          Utils::Git.current_branch
+        end
+
+        def prepare_deployment_metadata(last_deployment_commit = nil)
+          commit_info = Utils::Git.commit_info
+          committer_info = Utils::Git.committer_info
+
+          # Get file modifications since last deployment or since HEAD~1
+          file_modifications = if last_deployment_commit
+            Utils::Git.changed_files_since(last_deployment_commit)
+          else
+            Utils::Git.file_modifications
+          end
+
+          {
+            commit: commit_info[:sha],
+            commit_message: commit_info[:message],
+            committer_name: committer_info[:name],
+            committer_email: committer_info[:email],
+            file_modifications: file_modifications
+          }
+        end
+
+        def create_and_upload_archive(last_deployment_commit = nil, refreshed_imports: [])
+          if last_deployment_commit && Utils::Git.git_repo?
+            # Get changed file paths since last deployment
+            changed_paths = Utils::Git.changed_file_paths_since(last_deployment_commit)
+
+            if changed_paths.empty? && refreshed_imports.empty?
+              unless options[:force]
+                say "\nNo files changed since last deployment.", ColorHelper.warning
+                say "To force deploy, run command with --force or -f flag.\n", ColorHelper.info
+                exit(0)
+              end
+              Utils::Archive.create(project_path)
+            else
+              # Convert relative paths to absolute paths
+              files_to_include = changed_paths.map do |relative_path|
+                File.join(project_path, relative_path)
+              end.select { |path| File.exist?(path) }
+
+              change_count = files_to_include.length
+              if refreshed_imports.any?
+                change_count += refreshed_imports.length
+              end
+
+              say "Including #{change_count} changed file(s) in archive...\n", ColorHelper.info
+              Utils::Archive.create(project_path, files_to_include: files_to_include)
+            end
+          else
+            # No last deployment or not a git repo - include all files
+            Utils::Archive.create(project_path)
+          end
+        end
+
+        def submit_deployment(config, branch_id, archive_path, metadata)
+          client = API::Client.new(config["server"], config["api_key"])
+
+          with_spinner("Uploading files") do
+            client.create_deployment(config["project_id"], branch_id, archive_path, metadata)
+          end
+        ensure
+          FileUtils.rm_f(archive_path) if archive_path && File.exist?(archive_path)
+        end
+
+        def monitor_deployment(config, branch_id, deployment)
+          deployment_id = deployment["id"]
+          client = API::Client.new(config["server"], config["api_key"])
+
+          has_tests = test_files_exist?
+          Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id, has_tests: has_tests).start
+        end
+
+        def test_files_exist?
+          tests_dir = File.join(project_path, "tests")
+          return false unless File.directory?(tests_dir)
+
+          !Dir.glob(File.join(tests_dir, "*.{yml,yaml}")).empty?
+        end
+
+        def format_stage_name(stage)
+          stage.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+        end
+
+        def confirm_production_deploy(branch_id, config)
+          production_branch = get_production_branch(config)
+          return unless branch_id == production_branch
+
+          prompt = TTY::Prompt.new
+          message = "Deploying to production branch '#{branch_id}'. Continue? [y/N]"
+          return if prompt.yes?(message, default: false)
+
+          say "Deployment cancelled.", ColorHelper.warning
+          exit(0)
+        end
+
+        def get_production_branch(config)
+          return nil unless File.exist?("project.yml")
+
+          project_config = YAML.safe_load_file("project.yml", permitted_classes: [Date, Time], aliases: true) || {}
+          project_config["production_branch"] || "main"
+        rescue => e
+          warn "Failed to load project.yml: #{e.message}" if ENV["DEBUG"]
+          "main"
+        end
+
+        def get_last_successful_deployment_commit(config, branch_id)
+          return nil unless Utils::Git.git_repo?
+
+          client = API::Client.new(config["server"], config["api_key"])
+
+          begin
+            last_deployment = client.last_successful_deployment(config["project_id"], branch_id)
+            return nil unless last_deployment && last_deployment["commit"]
+
+            commit_hash = last_deployment["commit"]
+            say "Found last successful deployment at commit: #{commit_hash[0..7]}...\n", ColorHelper.info
+            commit_hash
+          rescue Strata::CommandError
+            # If we can't get last deployment (e.g., first deployment), continue with all files
+            say "No previous deployment found. Including all files.\n", ColorHelper.info
+            nil
+          end
+        end
+
+        def create_project_on_server(config)
+          project_config = YAML.safe_load_file("project.yml", permitted_classes: [Date, Time], aliases: true) || {}
+          name = project_config["name"]
+          uid = project_config["uid"]
+          description = project_config["description"]
+          git = project_config["git"]
+          production_branch = project_config["production_branch"]
+
+          unless name
+            raise Strata::CommandError, "Cannot create project: name is required in project.yml"
+          end
+
+          with_spinner("Creating project '#{name}' on server") do
+            client = API::Client.new(config["server"], config["api_key"])
+            project = client.create_project(name, uid, description: description, git: git, production_branch: production_branch)
+            project["id"]
+          end
+        end
+
+        def persist_project_id(project_id)
+          with_spinner("Persisting project ID to project.yml") do
+            Helpers::ProjectHelper.persist_project_id_to_yml(project_id)
+          end
+        end
+
+        def refresh_external_imports
+          refreshed = Utils::ImportManager.refresh_external_imports(project_path)
+
+          if refreshed.any?
+            say "\n Skimmed #{refreshed.length} external import(s):", ColorHelper.info
+            refreshed.each do |import|
+              filename = File.basename(import[:source])
+              say "  • #{filename}", ColorHelper.info
+            end
+          end
+
+          refreshed
+        end
+
+        def check_external_import_changes(project_path)
+          changed = Utils::ImportManager.check_changed_imports(project_path)
+          return [] unless changed.any?
+
+          changed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../guard"
+require_relative "../terminal"
+require_relative "../helpers/color_helper"
+require_relative "../helpers/project_helper"
+require_relative "../api/client"
+require "yaml"
+
+module Strata
+  module CLI
+    module SubCommands
+      class Project < Thor
+        include Guard
+        include Terminal
+
+        desc "link PROJECT_ID", "Link local project to an existing project on the server"
+        def link(project_id)
+          unless project_id && !project_id.to_s.strip.empty?
+            raise Strata::CommandError, "Project ID is required."
+          end
+
+          project_yml_path = "project.yml"
+          project_config = YAML.safe_load_file(project_yml_path, permitted_classes: [Date, Time], aliases: true) || {}
+
+          if project_config["project_id"] && !project_config["project_id"].to_s.strip.empty?
+            say "Project is already linked to project_id: #{project_config["project_id"]}", ColorHelper.warning
+            return
+          end
+
+          if Helpers::ProjectHelper.persist_project_id_to_yml(project_id, project_yml_path: project_yml_path)
+            say "✓ Project linked successfully. project_id: #{project_id}", ColorHelper.info
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../helpers/color_helper"
+require_relative "../helpers/prompts"
+require_relative "../helpers/command_context"
+
+module Strata
+  module CLI
+    module SubCommands
+      class Table < Thor
+        include Guard
+        include Terminal
+        include Prompts
+        include Thor::Actions
+        include Helpers::CommandContext
+        extend Helpers::DescriptionHelper
+
+        desc "list", "List all semantic models in the project"
+        def list
+          unless Dir.exist?("models")
+            say MSG_NO_MODELS_DIR, :yellow
+            return
+          end
+
+          model_files = Dir.glob("models/tbl[._]*.yml").sort
+
+          if model_files.empty?
+            say MSG_NO_MODELS_FOUND, :yellow
+            return
+          end
+
+          say MSG_MODELS_LIST_HEADER, :cyan
+
+          model_files.each do |file|
+            display_model_item(file)
+          end
+
+          say MSG_MODELS_COUNT % model_files.length, :cyan
+        end
+
+        private
+
+        def display_model_item(file)
+          name = File.basename(file, ".yml")
+          content = File.read(file)
+          desc = content.match(/^# Description: (.+)$/)&.[](1) || ""
+          desc = desc[0..50] + "..." if desc.length > 50
+
+          if desc.empty?
+            say "    #{name}", :white
+          else
+            say "    #{name.ljust(25)} #{desc}", :white
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/terminal.rb

@@ -0,0 +1,102 @@
+require "tty-spinner"
+require "pastel"
+require "tty-table"
+require "io/console"
+
+module Strata
+  module CLI
+    module Terminal
+      def create_spinner(message, message_color: :cyan, spinner_color: :cyan, format: :dots, clear: false)
+        pastel = Pastel.new
+
+        colored_message = pastel.send(message_color, message)
+        colored_spinner = "[#{pastel.send(spinner_color, ":spinner")}]"
+
+        TTY::Spinner.new("#{colored_spinner} #{colored_message}",
+          success_mark: pastel.green("✔"),
+          error_mark: pastel.red("✖"),
+          format: format,
+          clear: clear)
+      end
+
+      # Shows a loader while running IO tasks
+      # Uses consistent format matching deployment monitor: cyan spinner that transitions to checkmark
+      def with_spinner(message = "Loading...",
+        success_message: "",
+        failed_message: "",
+        clear: false,
+        message_color: :cyan,
+        spinner_color: :cyan,
+        format: :dots)
+        spinner = create_spinner(message,
+          message_color: message_color,
+          spinner_color: spinner_color,
+          format: format,
+          clear: clear)
+        spinner.auto_spin
+
+        begin
+          result = yield
+          spinner.success(success_message.empty? ? "" : Pastel.new.green(success_message))
+          result
+        rescue => e
+          spinner.error(failed_message.empty? ? "" : Pastel.new.red(failed_message))
+          raise e
+        end
+      end
+
+      def print_table(data, headers: nil, color: :magenta)
+        if data.empty?
+          say TTY::Table.new.render(:unicode), color
+          return
+        end
+
+        terminal_width = begin
+          IO.console.winsize[1]
+        rescue
+          80
+        end
+
+        actual_headers = headers || (0...data.first.length).map { |i| "Col#{i + 1}" }
+
+        # Calculate actual width needed for each column
+        column_widths = []
+        actual_headers.each_with_index do |header, i|
+          header_width = header.to_s.length
+          data_width = data.map { |row| row[i].to_s.length }.max || 0
+          column_widths << [header_width, data_width].max
+        end
+
+        # Table overhead: 2 for outer borders + 1 per column separator
+        table_overhead = 2 + (column_widths.length - 1) * 1
+        # Add 2 chars padding per column (space on each side)
+        total_padding = column_widths.length * 2
+
+        # Find how many columns fit
+        fitted_cols = 0
+        running_width = table_overhead + total_padding
+
+        column_widths.each_with_index do |width, _i|
+          break unless running_width + width <= terminal_width
+
+          running_width += width
+          fitted_cols += 1
+        end
+
+        # Ensure at least one column
+        fitted_cols = [fitted_cols, 1].max
+
+        # Create the table
+        limited_headers = actual_headers.first(fitted_cols)
+        limited_data = data.map { |row| row.first(fitted_cols) }
+
+        table = TTY::Table.new(header: limited_headers, rows: limited_data)
+        say table.render(:unicode, padding: [0, 1]), color
+        return unless fitted_cols < actual_headers.length
+
+        truncated = actual_headers.length - fitted_cols
+        say "(Showing #{fitted_cols}/#{actual_headers.length} columns - #{truncated} truncated)", :cyan
+      end
+    end
+  end
+end