shai-cli 0.1.0

data/lib/shai/commands/config.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Shai
+  module Commands
+    module Config
+      SHAIRC_FILE = ".shairc"
+
+      def self.included(base)
+        base.class_eval do
+          desc "config SUBCOMMAND", "Manage configuration metadata"
+          def config(subcommand = nil, *args)
+            case subcommand
+            when "show"
+              config_show
+            when "set"
+              config_set(args)
+            when nil
+              ui.error("Missing subcommand. Use `shai config show` or `shai config set`")
+              exit EXIT_INVALID_INPUT
+            else
+              ui.error("Unknown subcommand: #{subcommand}")
+              exit EXIT_INVALID_INPUT
+            end
+          end
+
+          desc "delete SLUG", "Delete a configuration"
+          def delete(slug)
+            require_auth!
+
+            unless ui.yes?("Are you sure you want to delete '#{slug}'? This cannot be undone.")
+              ui.info("Cancelled")
+              return
+            end
+
+            begin
+              ui.spinner("Deleting...") do
+                api.delete_configuration(slug)
+              end
+
+              ui.success("Configuration '#{slug}' deleted")
+            rescue NotFoundError
+              ui.error("Configuration '#{slug}' not found.")
+              exit EXIT_NOT_FOUND
+            rescue PermissionDeniedError
+              ui.error("You don't have permission to delete '#{slug}'.")
+              exit EXIT_PERMISSION_DENIED
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+        end
+      end
+
+      private
+
+      def config_show
+        require_auth!
+
+        shairc = load_shairc_for_config
+        slug = shairc["slug"]
+
+        begin
+          response = ui.spinner("Fetching configuration...") do
+            api.get_configuration(slug)
+          end
+
+          config = response["configuration"] || response
+
+          ui.info("Configuration: #{config["slug"]}")
+          ui.info("Name: #{config["name"]}")
+          ui.info("Description: #{config["description"] || "(none)"}")
+          ui.info("Visibility: #{config["visibility"]}")
+          owner = config["owner"]
+          owner_name = owner.is_a?(Hash) ? owner["username"] : owner
+          ui.info("Owner: #{owner_name || credentials.username}")
+          ui.info("Stars: #{config["stars_count"] || 0}")
+          ui.info("URL: #{Shai.configuration.api_url}/#{credentials.username}/#{config["slug"]}")
+          ui.info("Created: #{format_config_date(config["created_at"])}")
+          ui.info("Updated: #{format_config_date(config["updated_at"])}")
+        rescue NotFoundError
+          ui.error("Configuration '#{slug}' not found.")
+          exit EXIT_NOT_FOUND
+        rescue NetworkError => e
+          ui.error(e.message)
+          exit EXIT_NETWORK_ERROR
+        end
+      end
+
+      def config_set(args)
+        require_auth!
+
+        if args.length < 2
+          ui.error("Usage: shai config set <key> <value>")
+          ui.info("Valid keys: name, description, visibility")
+          exit EXIT_INVALID_INPUT
+        end
+
+        key = args[0]
+        value = args[1..].join(" ")
+
+        valid_keys = %w[name description visibility]
+        unless valid_keys.include?(key)
+          ui.error("Invalid key: #{key}")
+          ui.info("Valid keys: #{valid_keys.join(", ")}")
+          exit EXIT_INVALID_INPUT
+        end
+
+        if key == "visibility" && !%w[public private].include?(value)
+          ui.error("Visibility must be 'public' or 'private'")
+          exit EXIT_INVALID_INPUT
+        end
+
+        shairc = load_shairc_for_config
+        slug = shairc["slug"]
+
+        begin
+          ui.spinner("Updating...") do
+            api.update_configuration(slug, key.to_sym => value)
+          end
+
+          ui.success("Updated #{key} to '#{value}'")
+        rescue NotFoundError
+          ui.error("Configuration '#{slug}' not found.")
+          exit EXIT_NOT_FOUND
+        rescue PermissionDeniedError
+          ui.error("You don't have permission to modify this configuration.")
+          exit EXIT_PERMISSION_DENIED
+        rescue InvalidConfigurationError => e
+          ui.error(e.message)
+          exit EXIT_INVALID_INPUT
+        rescue NetworkError => e
+          ui.error(e.message)
+          exit EXIT_NETWORK_ERROR
+        end
+      end
+
+      def load_shairc_for_config
+        unless File.exist?(SHAIRC_FILE)
+          ui.error("No #{SHAIRC_FILE} file found. Run `shai init` to create one.")
+          exit EXIT_INVALID_INPUT
+        end
+
+        shairc = YAML.safe_load_file(SHAIRC_FILE)
+
+        unless shairc["slug"]
+          ui.error("Invalid #{SHAIRC_FILE} file. Missing required field: slug")
+          exit EXIT_INVALID_INPUT
+        end
+
+        shairc
+      rescue Psych::SyntaxError => e
+        ui.error("Invalid #{SHAIRC_FILE} file: #{e.message}")
+        exit EXIT_INVALID_INPUT
+      end
+
+      def format_config_date(date_string)
+        return "(unknown)" unless date_string
+
+        Time.parse(date_string).strftime("%B %-d, %Y")
+      rescue ArgumentError
+        date_string
+      end
+    end
+  end
+end

data/lib/shai/commands/configurations.rb

@@ -0,0 +1,393 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Shai
+  module Commands
+    module Configurations
+      INSTALLED_FILE = ".shai-installed"
+
+      def self.included(base)
+        base.class_eval do
+          desc "list", "List your configurations"
+          def list
+            require_auth!
+
+            begin
+              response = ui.spinner("Fetching configurations...") do
+                api.list_configurations
+              end
+
+              configs = response.is_a?(Array) ? response : response["configurations"]
+
+              if configs.empty?
+                ui.info("You don't have any configurations yet.")
+                ui.info("Run `shai init` to create one.")
+              else
+                ui.header("Your configurations:")
+                ui.blank
+                configs.each do |config|
+                  ui.display_configuration(config)
+                  ui.indent("Updated: #{time_ago(config["updated_at"])}")
+                  ui.blank
+                end
+              end
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+
+          desc "search QUERY", "Search public configurations"
+          option :tag, type: :array, default: [], desc: "Filter by tags"
+          def search(query = nil)
+            tags = options[:tag] || []
+
+            if query.nil? && tags.empty?
+              ui.error("Please provide a search query or tags")
+              exit EXIT_INVALID_INPUT
+            end
+
+            begin
+              response = ui.spinner("Searching...") do
+                api.search_configurations(query: query, tags: tags)
+              end
+
+              configs = response.is_a?(Array) ? response : response["configurations"]
+              search_term = query ? "\"#{query}\"" : "tags: #{tags.join(", ")}"
+
+              if configs.empty?
+                ui.info("No configurations found for #{search_term}")
+              else
+                ui.header("Search results for #{search_term}:")
+                ui.blank
+                configs.each do |config|
+                  ui.display_configuration(config, detailed: true)
+                  ui.blank
+                end
+                ui.info("Found #{configs.length} configuration(s). Use `shai install <name>` to install.")
+              end
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+
+          desc "install CONFIGURATION", "Install a configuration to local project"
+          option :force, type: :boolean, aliases: "-f", default: false, desc: "Overwrite existing files"
+          option :dry_run, type: :boolean, default: false, desc: "Show what would be installed"
+          option :path, type: :string, default: ".", desc: "Install to specific directory"
+          def install(configuration)
+            owner, slug = parse_configuration_name(configuration)
+            display_name = owner ? "#{owner}/#{slug}" : slug
+            base_path = File.expand_path(options[:path])
+            shairc_path = File.join(base_path, ".shairc")
+            installed_path = File.join(base_path, Shai::Commands::Configurations::INSTALLED_FILE)
+
+            # Check if a configuration is already installed/initialized
+            unless options[:force]
+              existing_slug = nil
+
+              if File.exist?(installed_path)
+                existing_config = begin
+                  YAML.safe_load_file(installed_path)
+                rescue
+                  {}
+                end
+                existing_slug = existing_config["slug"]
+              elsif File.exist?(shairc_path)
+                existing_config = begin
+                  YAML.safe_load_file(shairc_path)
+                rescue
+                  {}
+                end
+                existing_slug = existing_config["slug"]
+              end
+
+              if existing_slug
+                ui.error("A configuration is already present in this directory.")
+                ui.indent("Existing: #{existing_slug}")
+                ui.blank
+                ui.info("To install a different configuration:")
+                ui.indent("1. Run `shai uninstall #{existing_slug}` to remove the current configuration")
+                ui.indent("2. Then run `shai install #{display_name}`")
+                ui.blank
+                ui.info("Or use --force to install anyway (may cause conflicts)")
+                exit EXIT_INVALID_INPUT
+              end
+            end
+
+            begin
+              response = ui.spinner("Fetching #{display_name}...") do
+                api.get_tree(display_name)
+              end
+
+              tree = response["tree"]
+
+              # Security: Validate all paths before any file operations
+              validate_tree_paths!(tree, base_path)
+
+              # Check for conflicts
+              conflicts = []
+              tree.each do |node|
+                next if node["kind"] == "folder"
+
+                local_path = File.join(base_path, node["path"])
+                conflicts << node["path"] if File.exist?(local_path)
+              end
+
+              if options[:dry_run]
+                ui.header("Would install:")
+                tree.each { |node| ui.display_file_operation(:would_create, node["path"]) }
+                ui.blank
+                ui.info("No changes made (dry run)")
+                return
+              end
+
+              # Handle conflicts
+              if conflicts.any? && !options[:force]
+                ui.blank
+                ui.warning("The following files already exist:")
+                conflicts.each { |path| ui.display_file_operation(:conflict, path) }
+                ui.blank
+
+                choice = ui.select("Overwrite existing files?", [
+                  {name: "Yes", value: :yes},
+                  {name: "No (abort)", value: :no},
+                  {name: "Show diff", value: :diff}
+                ])
+
+                if choice == :diff
+                  show_install_diff(tree, base_path, conflicts)
+                  return unless ui.yes?("Overwrite existing files?")
+                elsif choice == :no
+                  ui.info("Installation cancelled")
+                  return
+                end
+              end
+
+              ui.header("Installing #{display_name}...")
+              ui.blank
+
+              # Create folders and files
+              created_count = 0
+              tree.sort_by { |n| (n["kind"] == "folder") ? 0 : 1 }.each do |node|
+                local_path = File.join(base_path, node["path"])
+
+                if node["kind"] == "folder"
+                  FileUtils.mkdir_p(local_path)
+                  ui.display_file_operation(:created, node["path"] + "/")
+                else
+                  FileUtils.mkdir_p(File.dirname(local_path))
+                  File.write(local_path, node["content"])
+                  ui.display_file_operation(:created, node["path"])
+                end
+                created_count += 1
+              end
+
+              # Write installation tracking file
+              installed_content = <<~YAML
+                # Installed by shai - do not edit manually
+                slug: "#{display_name}"
+                installed_at: "#{Time.now.iso8601}"
+              YAML
+              File.write(installed_path, installed_content)
+
+              ui.blank
+              ui.success("Installed #{created_count} items from #{display_name}")
+            rescue NotFoundError
+              ui.error("Configuration '#{display_name}' not found.")
+              exit EXIT_NOT_FOUND
+            rescue PermissionDeniedError
+              ui.error("You don't have permission to access '#{display_name}'.")
+              exit EXIT_PERMISSION_DENIED
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+
+          desc "uninstall [CONFIGURATION]", "Remove an installed configuration from local project"
+          option :dry_run, type: :boolean, default: false, desc: "Show what would be removed"
+          option :path, type: :string, default: ".", desc: "Path where configuration is installed"
+          def uninstall(configuration = nil)
+            require_auth!
+
+            base_path = File.expand_path(options[:path])
+            installed_path = File.join(base_path, INSTALLED_FILE)
+
+            # If no configuration specified, try to read from .shai-installed
+            if configuration.nil?
+              unless File.exist?(installed_path)
+                ui.error("No configuration specified and no .shai-installed file found.")
+                ui.info("Usage: shai uninstall <configuration>")
+                exit EXIT_INVALID_INPUT
+              end
+
+              installed_config = YAML.safe_load_file(installed_path)
+              configuration = installed_config["slug"]
+
+              unless configuration
+                ui.error("Could not read configuration from .shai-installed")
+                exit EXIT_INVALID_INPUT
+              end
+            end
+
+            owner, slug = parse_configuration_name(configuration)
+            display_name = owner ? "#{owner}/#{slug}" : slug
+
+            begin
+              response = ui.spinner("Fetching #{display_name}...") do
+                api.get_tree(display_name)
+              end
+
+              tree = response.is_a?(Array) ? response : response["tree"]
+
+              # Security: Validate all paths before any file operations
+              validate_tree_paths!(tree, base_path)
+
+              # Find files that exist locally
+              files_to_remove = []
+              folders_to_remove = []
+
+              tree.each do |node|
+                local_path = File.join(base_path, node["path"])
+
+                if node["kind"] == "folder"
+                  folders_to_remove << node["path"] if Dir.exist?(local_path)
+                elsif File.exist?(local_path)
+                  files_to_remove << node["path"]
+                end
+              end
+
+              if files_to_remove.empty? && folders_to_remove.empty?
+                ui.info("No files from '#{display_name}' found in #{base_path}")
+                return
+              end
+
+              if options[:dry_run]
+                ui.header("Would remove:")
+                files_to_remove.each { |path| ui.display_file_operation(:would_create, path) }
+                folders_to_remove.sort.reverse_each { |path| ui.display_file_operation(:would_create, path + "/") }
+                ui.blank
+                ui.info("No changes made (dry run)")
+                return
+              end
+
+              unless ui.yes?("Remove #{files_to_remove.length} files and #{folders_to_remove.length} folders from '#{display_name}'?")
+                ui.info("Uninstall cancelled")
+                return
+              end
+
+              ui.header("Uninstalling #{display_name}...")
+              ui.blank
+
+              # Remove files first
+              files_to_remove.each do |path|
+                local_path = File.join(base_path, path)
+                File.delete(local_path)
+                ui.display_file_operation(:deleted, path)
+              end
+
+              # Remove folders (deepest first)
+              folders_to_remove.sort.reverse_each do |path|
+                local_path = File.join(base_path, path)
+                if Dir.exist?(local_path) && Dir.empty?(local_path)
+                  Dir.rmdir(local_path)
+                  ui.display_file_operation(:deleted, path + "/")
+                end
+              end
+
+              # Remove installation tracking file
+              installed_path = File.join(base_path, Shai::Commands::Configurations::INSTALLED_FILE)
+              if File.exist?(installed_path)
+                File.delete(installed_path)
+                ui.display_file_operation(:deleted, Shai::Commands::Configurations::INSTALLED_FILE)
+              end
+
+              ui.blank
+              ui.success("Uninstalled #{display_name}")
+            rescue NotFoundError
+              ui.error("Configuration '#{display_name}' not found.")
+              exit EXIT_NOT_FOUND
+            rescue PermissionDeniedError
+              ui.error("You don't have permission to access '#{display_name}'.")
+              exit EXIT_PERMISSION_DENIED
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+        end
+      end
+
+      private
+
+      def parse_configuration_name(name)
+        if name.include?("/")
+          name.split("/", 2)
+        else
+          [nil, name]
+        end
+      end
+
+      # Security: Validate that a path is safe and doesn't escape base_path
+      def safe_path?(path, base_path)
+        return false if path.nil? || path.empty?
+        return false if path.start_with?("/") # No absolute paths
+        return false if path.include?("..") # No directory traversal
+        return false if path.include?("\0") # No null bytes
+
+        # Verify resolved path stays within base_path
+        full_path = File.expand_path(path, base_path)
+        full_path.start_with?(File.expand_path(base_path) + "/") || full_path == File.expand_path(base_path)
+      end
+
+      def validate_tree_paths!(tree, base_path)
+        tree.each do |node|
+          unless safe_path?(node["path"], base_path)
+            raise SecurityError, "Invalid path detected: #{node["path"].inspect}"
+          end
+        end
+      end
+
+      def time_ago(timestamp)
+        return "unknown" unless timestamp
+
+        seconds = Time.now - Time.parse(timestamp)
+        case seconds
+        when 0..59
+          "just now"
+        when 60..3599
+          "#{(seconds / 60).to_i} minutes ago"
+        when 3600..86399
+          hours = (seconds / 3600).to_i
+          (hours == 1) ? "1 hour ago" : "#{hours} hours ago"
+        when 86400..604799
+          days = (seconds / 86400).to_i
+          (days == 1) ? "yesterday" : "#{days} days ago"
+        else
+          Time.parse(timestamp).strftime("%B %-d, %Y")
+        end
+      rescue ArgumentError
+        timestamp
+      end
+
+      def show_install_diff(tree, base_path, conflicts)
+        require "diffy"
+
+        conflicts.each do |path|
+          local_path = File.join(base_path, path)
+          local_content = File.read(local_path)
+          remote_content = tree.find { |n| n["path"] == path }&.dig("content") || ""
+
+          ui.info("--- local #{path}")
+          ui.info("+++ remote #{path}")
+          diff = Diffy::Diff.new(local_content, remote_content, context: 3)
+          ui.diff(diff.to_s)
+          ui.blank
+        end
+      end
+    end
+  end
+end