deploio-cli 0.1.0 → 0.2.0

data/lib/deploio/output.rb

@@ -42,6 +42,15 @@ module Deploio
         puts pastel.magenta.bold(text)
       end
 
+      # Create a clickable hyperlink using OSC 8 escape sequences
+      # Supported by most modern terminal emulators (iTerm2, GNOME Terminal, Windows Terminal, etc.)
+      def link(text, url = nil)
+        return text unless color_enabled
+
+        url ||= text.start_with?("http") ? text : "https://#{text}"
+        "\e]8;;#{url}\e\\#{text}\e]8;;\e\\"
+      end
+
       def table(rows, headers: nil)
         return if rows.empty?
 
@@ -49,6 +58,37 @@ module Deploio
         puts tty_table.render(:unicode, padding: [0, 2, 0, 1], width: 10_000)
       end
 
+      def list(items)
+        items.each { |item| puts "  • #{item}" }
+      end
+
+      def grouped_table(groups, headers: nil)
+        return if groups.empty?
+
+        all_rows = groups.values.flatten(1)
+        return if all_rows.empty?
+
+        # Track which row indices should have separators after them (0-indexed)
+        # The separator lambda receives the row index (0 = first data row)
+        separator_after = []
+        current_idx = 0
+        groups.each_with_index do |(_, group_rows), group_idx|
+          current_idx += group_rows.size
+          # Add separator after last row of each group (except the last group)
+          separator_after << (current_idx - 1) if group_idx < groups.size - 1
+        end
+
+        rows = groups.values.flatten(1)
+        tty_table = headers ? TTY::Table.new(header: headers, rows: rows) : TTY::Table.new(rows: rows)
+
+        output = tty_table.render(:unicode, padding: [0, 2, 0, 1], width: 10_000) do |renderer|
+          # row_idx 0 = separator after header, then data row indices
+          renderer.border.separator = ->(row_idx) { row_idx == 0 || separator_after.include?(row_idx - 1) }
+        end
+
+        puts output
+      end
+
       private
 
       def pastel

data/lib/deploio/pg_database_ref.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module Deploio
+  class PgDatabaseRef
+    attr_reader :project_name, :database_name
+
+    # The input is given in the format "<project>-<database>"
+    def initialize(input, available_databases: {})
+      @input = input.to_s
+      parse_from_available_databases(available_databases)
+    end
+
+    def full_name
+      "#{project_name}-#{database_name}"
+    end
+
+    def to_s
+      full_name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(PgDatabaseRef)
+
+      project_name == other.project_name && database_name == other.database_name
+    end
+
+    private
+
+    def parse_from_available_databases(available_databases)
+      if available_databases.key?(@input)
+        match = available_databases[@input]
+        @project_name = match[:project_name]
+        @database_name = match[:database_name]
+        return
+      end
+
+      # If available_databases provided but no match, raise error with suggestions
+      raise_not_found_error(@input, available_databases.keys) unless available_databases.empty?
+
+      raise_not_found_error(@input, [])
+    end
+
+    def raise_not_found_error(input, available_database_names)
+      message = "Database not found: '#{input}'"
+
+      suggestions = suggest_similar(input, available_database_names)
+      unless suggestions.empty?
+        message += "\n\nDid you mean?"
+        suggestions.each { |s| message += "\n  #{s}" }
+      end
+
+      message += "\n\nRun 'deploio pg' to see available Postgres databases."
+
+      raise Deploio::PgDatabaseNotFoundError, message
+    end
+
+    def suggest_similar(input, dictionary)
+      return [] if dictionary.empty?
+
+      spell_checker = DidYouMean::SpellChecker.new(dictionary: dictionary)
+      spell_checker.correct(input)
+    end
+  end
+end

data/lib/deploio/pg_database_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Deploio
+  class PgDatabaseResolver
+    attr_reader :nctl, :current_org
+
+    def initialize(nctl_client:)
+      @nctl = nctl_client
+      @current_org = @nctl.current_org
+    end
+
+    def resolve(database_name: nil)
+      if database_name
+        return PgDatabaseRef.new(database_name, available_databases: available_databases_hash)
+      end
+
+      raise Deploio::Error, "No database specified"
+    end
+
+    # Returns hash mapping database names -> {project_name:, app_name:}
+    def available_databases_hash
+      @available_apps_hash ||= begin
+        hash = {}
+        current_org = @nctl.current_org
+        @nctl.get_all_pg_databases.each do |database|
+          metadata = database["metadata"] || {}
+          project_name = metadata["namespace"] || ""
+          database_name = metadata["name"]
+          full_name = "#{project_name}-#{database_name}"
+          hash[full_name] = {project_name: project_name, database_name: database_name}
+
+          # Also index by short name (without org prefix) for convenience
+          if current_org && project_name.start_with?("#{current_org}-")
+            project = project_name.delete_prefix("#{current_org}-")
+            short_name = "#{project}-#{database_name}"
+            hash[short_name] ||= {project_name: project_name, database_name: database_name}
+          end
+        end
+        hash
+      end
+    rescue
+      {}
+    end
+
+    def short_name_for(namespace, database_name)
+      org = current_org
+      if org && namespace.start_with?("#{org}-")
+        project = namespace.delete_prefix("#{org}-")
+        "#{project}-#{database_name}"
+      else
+        "#{namespace}-#{database_name}"
+      end
+    end
+  end
+end

data/lib/deploio/price_fetcher.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+require "fileutils"
+
+module Deploio
+  class PriceFetcher
+    CACHE_DIR = File.expand_path("~/.deploio")
+    CACHE_FILE = File.join(CACHE_DIR, "prices.json")
+    CACHE_TTL = 24 * 60 * 60 # 24 hours in seconds
+    API_URL = "https://calculator-api-production.2deb129.deploio.app/product"
+
+    def initialize
+      @prices = nil
+    end
+
+    def fetch
+      @prices ||= load_cached_prices || fetch_and_cache_prices
+    end
+
+    def price_for_service(type, spec)
+      fetch
+      return nil unless @prices
+
+      case type
+      when "postgres", "mysql"
+        price_for_database(type, spec)
+      when "postgresdatabases", "mysqldatabases"
+        price_for_single_database
+      when "keyvaluestore"
+        price_for_keyvaluestore(spec)
+      when "opensearch"
+        price_for_opensearch
+      when "bucket"
+        price_for_bucket
+      end
+    end
+
+    def price_for_app(app_data)
+      fetch
+      return nil unless @prices
+
+      spec = app_data["spec"] || app_data
+      status = app_data["status"] || {}
+      for_provider = spec["forProvider"] || {}
+      at_provider = status["atProvider"] || {}
+      config = for_provider["config"] || {}
+
+      size = (config["size"] || "micro").downcase
+      # Use status replicas (actual running) if available, otherwise spec replicas, default to 1
+      replicas = at_provider["replicas"] || for_provider["replicas"] || 1
+      replicas = replicas.to_i
+
+      size_price = @prices.dig("app", size)
+      return nil if size_price.nil?
+
+      size_price * replicas
+    end
+
+    def format_price(price)
+      return "-" if price.nil?
+
+      "CHF #{price}/mo"
+    end
+
+    private
+
+    def load_cached_prices
+      return nil unless File.exist?(CACHE_FILE)
+
+      cache_data = JSON.parse(File.read(CACHE_FILE))
+      cached_at = cache_data["cached_at"]
+      return nil if cached_at.nil? || Time.now.to_i - cached_at > CACHE_TTL
+
+      cache_data["prices"]
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+
+    def fetch_and_cache_prices
+      prices = fetch_prices_from_api
+      return nil if prices.nil?
+
+      cache_prices(prices)
+      prices
+    rescue
+      nil
+    end
+
+    def fetch_prices_from_api
+      uri = URI.parse(API_URL)
+      response = Net::HTTP.get_response(uri)
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      products = JSON.parse(response.body)
+      build_price_map(products)
+    rescue JSON::ParserError, Net::OpenTimeout, Net::ReadTimeout, SocketError
+      nil
+    end
+
+    def build_price_map(products)
+      prices = {
+        "postgres" => {},
+        "mysql" => {},
+        "keyvaluestore" => {"base" => 15},
+        "opensearch" => {"base" => 60},
+        "single_database" => {"base" => 5},
+        "bucket" => {"base" => 0},
+        "app" => {"micro" => 8, "mini" => 16, "standard-1" => 32, "standard-2" => 58},
+        "ram_per_gib" => 5
+      }
+
+      products.each do |product|
+        name = product["name"]
+        list_price = product["list_price"]
+        categ_path = (product["categ_path"] || []).join("/")
+
+        case name
+        when /^PostgreSQL - (nine-(?:db|single-db)-\S+)/
+          machine_type = normalize_machine_type($1)
+          prices["postgres"][machine_type] = list_price
+        when /^MySQL - (nine-(?:db|single-db)-\S+)/
+          machine_type = normalize_machine_type($1)
+          prices["mysql"][machine_type] = list_price
+        when "Managed Service: Key-Value Store (Redis compatible)"
+          prices["keyvaluestore"]["base"] = list_price
+        when "Managed Service: OpenSearch (Elasticsearch compatible)"
+          prices["opensearch"]["base"] = list_price
+        when "Micro", "Mini", "Standard-1", "Standard-2"
+          # Only use deplo.io app sizes
+          prices["app"][name.downcase] = list_price if categ_path.include?("deplo")
+        end
+      end
+
+      prices
+    end
+
+    def normalize_machine_type(raw)
+      # "nine-single-db-l - 10GB" -> "nine-single-db-l"
+      raw.split(" ").first
+    end
+
+    def cache_prices(prices)
+      FileUtils.mkdir_p(CACHE_DIR)
+      cache_data = {
+        "cached_at" => Time.now.to_i,
+        "prices" => prices
+      }
+      File.write(CACHE_FILE, JSON.pretty_generate(cache_data))
+    end
+
+    def price_for_database(type, spec)
+      for_provider = spec.dig("forProvider") || {}
+      machine_type = for_provider["machineType"] || for_provider["singleDBMachineType"]
+      return nil if machine_type.nil?
+
+      @prices.dig(type, machine_type)
+    end
+
+    def price_for_keyvaluestore(spec)
+      base_price = @prices.dig("keyvaluestore", "base") || 15
+      ram_price = @prices["ram_per_gib"] || 5
+
+      memory_size = spec.dig("forProvider", "memorySize")
+      return base_price if memory_size.nil?
+
+      # Parse memory size (e.g., "256Mi", "1Gi", "512Mi")
+      gib = parse_memory_to_gib(memory_size)
+      (base_price + (gib * ram_price)).round
+    end
+
+    def price_for_opensearch
+      @prices.dig("opensearch", "base") || 60
+    end
+
+    def price_for_single_database
+      # Single databases on shared instances - base price for smallest tier
+      @prices.dig("single_database", "base") || 5
+    end
+
+    def price_for_bucket
+      # Buckets are usage-based, show base/minimum price
+      @prices.dig("bucket", "base") || 0
+    end
+
+    def parse_memory_to_gib(memory_str)
+      case memory_str
+      when /^(\d+(?:\.\d+)?)Gi$/
+        $1.to_f
+      when /^(\d+(?:\.\d+)?)Mi$/
+        $1.to_f / 1024
+      when /^(\d+(?:\.\d+)?)Ki$/
+        $1.to_f / (1024 * 1024)
+      else
+        0
+      end
+    end
+  end
+end

data/lib/deploio/shared_options.rb

@@ -30,6 +30,7 @@ module Deploio
       @nctl.check_requirements unless merged_options[:dry_run]
     end
 
+    # @return [Deploio::AppRef]
     def resolve_app
       resolver = AppResolver.new(nctl_client: @nctl)
       resolver.resolve(app_name: merged_options[:app])
@@ -37,5 +38,20 @@ module Deploio
       Output.error(e.message)
       exit 1
     end
+
+    # Resolves a project name to its fully qualified form (org-project).
+    # Users can type short names like "myproject" and this will prepend the org.
+    # @param project [String] Project name (short or fully qualified)
+    # @return [String] Fully qualified project name
+    def resolve_project(project)
+      current_org = @nctl.current_org
+      return project unless current_org
+
+      # Special case: project equals org name (default project)
+      return project if project == current_org
+
+      # Always prepend org to get fully qualified name
+      "#{current_org}-#{project}"
+    end
   end
 end

data/lib/deploio/templates/completion.zsh.erb

@@ -23,6 +23,58 @@ _<%= program_name %>_orgs_list() {
   fi
 }
 
+# Dynamic completion for services
+_<%= program_name %>_services_list() {
+  local -a services
+  services=(${(f)"$(<%= program_name %> services --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |s|
+      ns = s.dig("metadata", "namespace") || ""
+      name = s.dig("metadata", "name") || ""
+      type = s["_type"] || "unknown"
+      project = current_org && ns.start_with?("#{current_org}-") ? ns.delete_prefix("#{current_org}-") : ns
+      short_name = "#{project}-#{name}"
+      puts "#{short_name}:#{name} (#{type})"
+    end
+  ' 2>/dev/null)"})
+
+  if [[ ${#services[@]} -gt 0 ]]; then
+    _describe -t services 'available services' services
+  else
+    _message 'service (format: project-servicename)'
+  fi
+}
+
+# Dynamic completion for projects
+_<%= program_name %>_projects_list() {
+  local -a projects
+  projects=(${(f)"$(<%= program_name %> projects --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |p|
+      name = p.dig("metadata", "name") || ""
+      display_name = p.dig("spec", "displayName").to_s
+      # Strip org prefix from project name for short name
+      short_name = current_org && name.start_with?("#{current_org}-") ? name.delete_prefix("#{current_org}-") : name
+      label = display_name.length > 0 ? display_name : short_name
+      puts "#{short_name}:#{label}"
+    end
+  ' 2>/dev/null)"})
+
+  if [[ ${#projects[@]} -gt 0 ]]; then
+    _describe -t projects 'available projects' projects
+  else
+    _message 'project name'
+  fi
+}
+
 # Dynamic completion for apps
 _<%= program_name %>_apps_list() {
   local -a apps
@@ -48,7 +100,37 @@ _<%= program_name %>_apps_list() {
   fi
 }
 
-<% subcommands.each do |name, commands, class_options| %>
+# Dynamic completion for PostgreSQL databases
+_<%= program_name %>_pg_databases_list() {
+  local -a databases
+  databases=(${(f)"$(<%= program_name %> pg list --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    orgs_json = `<%= program_name %> orgs --json 2>/dev/null` rescue "[]"
+    orgs = JSON.parse(orgs_json) rescue []
+    current_org = orgs.find { |o| o["current"] }&.fetch("name", nil)
+
+    data.each do |db|
+      metadata = db["metadata"] || {}
+      spec = db["spec"] || {}
+      for_provider = spec["forProvider"] || {}
+      ns = metadata["namespace"] || ""
+      name = metadata["name"] || ""
+      version = for_provider["version"] || "?"
+      kind = db["kind"] || ""
+      project = current_org && ns.start_with?("#{current_org}-") ? ns.delete_prefix("#{current_org}-") : ns
+      short_name = "#{project}-#{name}"
+      puts "#{short_name}:#{name} (#{kind}, v#{version})"
+    end
+  ' 2>/dev/null)"})
+
+  if [[ ${#databases[@]} -gt 0 ]]; then
+    _describe -t databases 'available PostgreSQL databases' databases
+  else
+    _message 'database (format: project-dbname)'
+  fi
+}
+
+<% subcommands.each do |name, commands, class_options, default_task, klass| %>
 # <%= name %> subcommand
 _<%= program_name %>_<%= name %>() {
   local -a <%= name %>_commands
@@ -58,6 +140,20 @@ _<%= program_name %>_<%= name %>() {
 <% end -%>
   )
 
+<% default_cmd = commands.find { |cmd_name, _, _| cmd_name == default_task } -%>
+<% if default_cmd -%>
+  # Handle options directly (for default task) or subcommand
+  # Check if current word or next word after subcommand starts with -
+  local first_arg="${words[2]}"
+  local current_word="${words[CURRENT]}"
+  if [[ "$first_arg" == -* ]] || [[ "$current_word" == -* ]] || [[ -z "$first_arg" && "$current_word" == -* ]]; then
+    # Options provided directly - use default task (<%= default_task %>)
+    _arguments -s \
+<%= format_options(default_cmd[2], class_options, positional_arg(name, default_task)) %>
+    return
+  fi
+
+<% end -%>
   _arguments -s \
     '1:<%= name %> command:-><%= name %>_cmd' \
     '*::<%= name %> args:-><%= name %>_args'
@@ -70,8 +166,45 @@ _<%= program_name %>_<%= name %>() {
       case "$words[1]" in
 <% commands.each do |cmd_name, _, options| -%>
         <%= cmd_name %>)
+<% if klass.subcommand_classes.key?(cmd_name) -%>
+          _<%= program_name %>_<%= name %>_<%= cmd_name %>
+<% else -%>
           _arguments -s \
 <%= format_options(options, class_options, positional_arg(name, cmd_name)) %>
+<% end -%>
+          ;;
+<% end -%>
+      esac
+      ;;
+  esac
+}
+<% end %>
+
+<% nested_subcommands.each do |full_name, commands, class_options| %>
+<% parent_name, nested_name = full_name.split(':') %>
+# <%= full_name %> nested subcommand
+_<%= program_name %>_<%= parent_name %>_<%= nested_name %>() {
+  local -a <%= nested_name %>_commands
+  <%= nested_name %>_commands=(
+<% commands.each do |cmd_name, desc| -%>
+    '<%= cmd_name %>:<%= escape(desc) %>'
+<% end -%>
+  )
+
+  _arguments -s \
+    '1:<%= nested_name %> command:-><%= nested_name %>_cmd' \
+    '*::<%= nested_name %> args:-><%= nested_name %>_args'
+
+  case "$state" in
+    <%= nested_name %>_cmd)
+      _describe -t commands '<%= nested_name %> commands' <%= nested_name %>_commands
+      ;;
+    <%= nested_name %>_args)
+      case "$words[1]" in
+<% commands.each do |cmd_name, _, options| -%>
+        <%= cmd_name %>)
+          _arguments -s \
+<%= format_options(options, class_options, positional_arg(full_name, cmd_name)) %>
           ;;
 <% end -%>
       esac

data/lib/deploio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deploio
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/deploio.rb

@@ -6,13 +6,17 @@ require_relative "deploio/version"
 require_relative "deploio/utils"
 require_relative "deploio/output"
 require_relative "deploio/app_ref"
+require_relative "deploio/pg_database_ref"
 require_relative "deploio/nctl_client"
 require_relative "deploio/app_resolver"
+require_relative "deploio/pg_database_resolver"
+require_relative "deploio/price_fetcher"
 require_relative "deploio/shared_options"
 require_relative "deploio/cli"
 
 module Deploio
   class Error < StandardError; end
   class AppNotFoundError < Error; end
+  class PgDatabaseNotFoundError < Error; end
   class NctlError < Error; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deploio-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Renuo AG
@@ -56,10 +56,18 @@ files:
 - lib/deploio/cli.rb
 - lib/deploio/commands/apps.rb
 - lib/deploio/commands/auth.rb
+- lib/deploio/commands/builds.rb
 - lib/deploio/commands/orgs.rb
+- lib/deploio/commands/postgresql.rb
+- lib/deploio/commands/postgresql_backups.rb
+- lib/deploio/commands/projects.rb
+- lib/deploio/commands/services.rb
 - lib/deploio/completion_generator.rb
 - lib/deploio/nctl_client.rb
 - lib/deploio/output.rb
+- lib/deploio/pg_database_ref.rb
+- lib/deploio/pg_database_resolver.rb
+- lib/deploio/price_fetcher.rb
 - lib/deploio/shared_options.rb
 - lib/deploio/templates/completion.zsh.erb
 - lib/deploio/utils.rb
@@ -72,6 +80,11 @@ metadata:
   homepage_uri: https://github.com/renuo/deploio-cli
   source_code_uri: https://github.com/renuo/deploio-cli
   changelog_uri: https://github.com/renuo/deploio-cli/blob/main/CHANGELOG.md
+post_install_message: |+
+  To enable shell autocompletion for deploio, add this to your ~/.zshrc:
+
+      eval "$(deploio completion)"
+
 rdoc_options: []
 require_paths:
 - lib
@@ -86,7 +99,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: CLI for Deploio
 test_files: []
+...