deploio-cli 0.1.0

data/lib/deploio/commands/orgs.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Deploio
+  module Commands
+    class Orgs < Thor
+      include SharedOptions
+
+      namespace "orgs"
+
+      class_option :json, type: :boolean, default: false, desc: "Output as JSON"
+
+      default_task :list
+
+      desc "list", "List all organizations"
+      def list
+        setup_options
+        raw_orgs = @nctl.get_orgs
+
+        if options[:json]
+          puts JSON.pretty_generate(raw_orgs)
+          return
+        end
+
+        if raw_orgs.empty?
+          Output.warning("No organizations found") unless merged_options[:dry_run]
+          return
+        end
+
+        rows = raw_orgs.map do |org|
+          current_marker = org["current"] ? "*" : ""
+          [
+            current_marker,
+            presence(org["name"])
+          ]
+        end
+
+        Output.table(rows, headers: ["", "ORGANIZATION"])
+      end
+
+      desc "set ORG_NAME", "Set the current organization"
+      def set(org_name)
+        setup_options
+        @nctl.set_org(org_name)
+        Output.success("Switched to organization #{org_name}")
+      end
+
+      private
+
+      def presence(value, default: "-")
+        (value.nil? || value.to_s.empty?) ? default : value
+      end
+    end
+  end
+end

data/lib/deploio/completion_generator.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Deploio
+  # Generates zsh completion script from Thor command metadata.
+  # Can be reused with any Thor-based CLI by passing the CLI class.
+  #
+  # @example Basic usage
+  #   CompletionGenerator.new(MyCLI).generate
+  #
+  # @example With custom option completers
+  #   CompletionGenerator.new(MyCLI, option_completers: {
+  #     'env' => 'environment:(production staging development)'
+  #   }).generate
+  #
+  class CompletionGenerator
+    TEMPLATE_PATH = File.expand_path("templates/completion.zsh.erb", __dir__)
+
+    # Commands that pass through to external programs (like exec)
+    # These get '*:command:_normal' as their final argument
+    PASSTHROUGH_COMMANDS = %w[exec run].freeze
+
+    attr_reader :cli_class, :option_completers, :positional_completers, :program_name
+
+    # @param cli_class [Class] Thor CLI class to generate completions for
+    # @param option_completers [Hash] Custom completers for specific options
+    #   e.g., { 'app' => 'app:_myapp_apps_list' }
+    # @param positional_completers [Hash] Custom completers for positional args
+    #   e.g., { 'orgs:set' => "'1:organization:_myapp_orgs_list'" }
+    # @param program_name [String] Override the program name (default: derived from CLI class)
+    def initialize(cli_class = nil, option_completers: {}, positional_completers: {}, program_name: nil)
+      @cli_class = cli_class || default_cli_class
+      @program_name = program_name || derive_program_name
+      @option_completers = default_option_completers.merge(option_completers)
+      @positional_completers = default_positional_completers.merge(positional_completers)
+    end
+
+    def generate
+      template = File.read(TEMPLATE_PATH)
+      ERB.new(template, trim_mode: "-").result(binding)
+    end
+
+    private
+
+    def default_cli_class
+      require_relative "cli"
+      CLI
+    end
+
+    def default_option_completers
+      {
+        "app" => "app:_#{program_name}_apps_list",
+        "size" => "size:(micro mini standard)"
+      }
+    end
+
+    def default_positional_completers
+      {
+        "orgs:set" => "'1:organization:_#{program_name}_orgs_list'"
+      }
+    end
+
+    def derive_program_name
+      # Convert "Deploio::CLI" -> "deploio", "MyApp::CLI" -> "myapp"
+      cli_class.name.split("::").first.downcase
+    end
+
+    def subcommands
+      cli_class.subcommand_classes.map do |name, klass|
+        commands = klass.commands.except("help").map do |cmd_name, cmd|
+          [cmd_name, cmd.description, cmd.options]
+        end
+        [name, commands, klass.class_options]
+      end
+    end
+
+    def main_commands
+      cli_class.commands.except("help").map do |name, cmd|
+        [name, cmd.description]
+      end
+    end
+
+    def direct_commands
+      subcommand_names = cli_class.subcommands
+      cli_class.commands.reject do |name, _|
+        name == "help" || subcommand_names.include?(name) || passthrough_command?(name)
+      end.map do |name, cmd|
+        [name, cmd.options]
+      end
+    end
+
+    def passthrough_commands
+      PASSTHROUGH_COMMANDS.filter_map do |name|
+        cmd = cli_class.commands[name]
+        [name, cmd.options] if cmd
+      end
+    end
+
+    def passthrough_command?(name)
+      PASSTHROUGH_COMMANDS.include?(name)
+    end
+
+    def cli_class_options
+      cli_class.class_options
+    end
+
+    def positional_arg(subcommand, cmd_name)
+      positional_completers["#{subcommand}:#{cmd_name}"]
+    end
+
+    def format_options(method_options, class_options, extra_arg = nil)
+      all_options = cli_class.class_options.merge(class_options).merge(method_options)
+      lines = all_options.map { |name, opt| format_option(name, opt) }.compact
+      lines << extra_arg if extra_arg
+
+      return "            # No options" if lines.empty?
+
+      lines.map.with_index do |line, i|
+        continuation = (i < lines.size - 1) ? " \\" : ""
+        "            #{line}#{continuation}"
+      end.join("\n")
+    end
+
+    def format_option(name, opt)
+      flag = name.to_s.tr("_", "-")
+      short = opt.aliases&.first
+      desc = escape(opt.description || "")
+      completer = option_completer(name, flag)
+
+      if short
+        if opt.type == :boolean
+          "'(#{short} --#{flag})'{#{short},--#{flag}}'[#{desc}]'"
+        else
+          "'(#{short} --#{flag})'{#{short},--#{flag}}'[#{desc}]:#{completer}'"
+        end
+      elsif opt.type == :boolean
+        "'--#{flag}[#{desc}]'"
+      else
+        "'--#{flag}[#{desc}]:#{completer}'"
+      end
+    end
+
+    def option_completer(name, flag)
+      option_completers[name.to_s] || "#{flag}:"
+    end
+
+    def escape(text)
+      text.to_s.gsub("'", "'\\''").gsub("[", '\\[').gsub("]", '\\]')
+    end
+  end
+end

data/lib/deploio/nctl_client.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Deploio
+  class NctlClient
+    REQUIRED_VERSION = "1.10.0"
+
+    attr_reader :dry_run
+
+    def initialize(dry_run: false)
+      @dry_run = dry_run
+    end
+
+    def check_requirements
+      check_nctl_installed
+      check_nctl_version
+    end
+
+    def logs(app_ref, tail: false, lines: 100)
+      args = ["--lines=#{lines}"]
+      args << "-f" if tail
+      exec_passthrough("logs", "app", app_ref.app_name,
+        "--project", app_ref.project_name,
+        *args)
+    end
+
+    def exec_command(app_ref, command)
+      exec_passthrough("exec", "app", app_ref.app_name,
+        "--project", app_ref.project_name,
+        "--", *command)
+    end
+
+    def get_all_apps
+      @all_apps ||= begin
+        output = capture("get", "apps", "-A", "-o", "json")
+        return [] if output.nil? || output.empty?
+
+        data = JSON.parse(output)
+        data.is_a?(Array) ? data : (data["items"] || [])
+      rescue JSON::ParserError
+        []
+      end
+    end
+
+    def get_app(app_ref)
+      output = capture("get", "app", app_ref.app_name,
+        "--project", app_ref.project_name,
+        "-o", "json")
+      return {} if output.nil? || output.empty?
+
+      JSON.parse(output)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def get_app_stats(app_ref)
+      capture("get", "app", app_ref.app_name,
+        "--project", app_ref.project_name,
+        "-o", "stats")
+    end
+
+    def edit_app(app_ref)
+      exec_passthrough("edit", "app", app_ref.app_name,
+        "--project", app_ref.project_name)
+    end
+
+    def create_app(project, app_name, git_url:, git_revision:, size: "mini")
+      run("create", "app", app_name,
+        "--project", project,
+        "--git-url", git_url,
+        "--git-revision", git_revision,
+        "--size", size)
+    end
+
+    def delete_app(app_ref)
+      run("delete", "app", app_ref.app_name,
+        "--project", app_ref.project_name)
+    end
+
+    def create_project(project_name)
+      run("create", "project", project_name)
+    end
+
+    def get_projects
+      output = capture("get", "projects", "-o", "json")
+      return [] if output.nil? || output.empty?
+
+      data = JSON.parse(output)
+      data.is_a?(Array) ? data : (data["items"] || [])
+    rescue JSON::ParserError
+      []
+    end
+
+    def get_orgs
+      output = capture("auth", "whoami")
+      return [] if output.nil? || output.empty?
+
+      parse_orgs_from_whoami(output)
+    end
+
+    def current_org
+      get_orgs.find { |o| o["current"] }&.fetch("name", nil)
+    end
+
+    def parse_orgs_from_whoami(output)
+      orgs = []
+      in_orgs_section = false
+
+      output.each_line do |line|
+        if line.include?("Available Organizations:")
+          in_orgs_section = true
+          next
+        end
+
+        next unless in_orgs_section
+        break if line.strip.empty? || line.start_with?("To switch")
+
+        # Lines are either "*\torg_name" (current) or "\torg_name"
+        current = line.start_with?("*")
+        org_name = line.sub(/^\*?\t/, "").strip
+        next if org_name.empty?
+
+        orgs << {"name" => org_name, "current" => current}
+      end
+
+      orgs
+    end
+
+    def set_org(org_name)
+      run("auth", "set-org", org_name)
+    end
+
+    def auth_login
+      exec_passthrough("auth", "login")
+    end
+
+    def auth_logout
+      run("auth", "logout")
+    end
+
+    def auth_whoami
+      exec_passthrough("auth", "whoami")
+    end
+
+    private
+
+    # Runs nctl command as subprocess with output to terminal. Used for
+    # commands that modify state (create, delete) where we show output but don't need to parse it.
+    def run(*args)
+      cmd = build_command(args)
+      Output.command(cmd.join(" "))
+      if dry_run
+        true
+      else
+        system(*cmd)
+      end
+    end
+
+    # Replaces current process with nctl command. Used for interactive commands
+    # (logs -f, exec, edit, auth) that need direct terminal access. Never returns.
+    def exec_passthrough(*args)
+      cmd = build_command(args)
+      Output.command(cmd.join(" "))
+      if dry_run
+        true
+      else
+        exec(*cmd)
+      end
+    end
+
+    # Runs nctl command and captures stdout. Used for commands that return data
+    # (get apps, get projects) that needs to be parsed. Raises on failure.
+    def capture(*args)
+      cmd = build_command(args)
+      if dry_run
+        Output.command(cmd.join(" "))
+        ""
+      else
+        stdout, stderr, status = Open3.capture3(*cmd)
+        unless status.success?
+          raise Deploio::NctlError, "nctl command failed: #{stderr}"
+        end
+
+        stdout
+      end
+    end
+
+    def build_command(args)
+      ["nctl"] + args.map(&:to_s)
+    end
+
+    def check_nctl_installed
+      _stdout, _stderr, status = Open3.capture3("nctl", "--version")
+      return if status.success?
+
+      raise Deploio::NctlError,
+        "nctl not found. Please install it: https://github.com/ninech/nctl"
+    end
+
+    def check_nctl_version
+      stdout, _stderr, _status = Open3.capture3("nctl", "--version")
+      version_match = stdout.match(/(\d+\.\d+\.\d+)/)
+      return unless version_match
+
+      version = version_match[1]
+      return unless Gem::Version.new(version) < Gem::Version.new(REQUIRED_VERSION)
+
+      raise Deploio::NctlError,
+        "nctl version #{version} is too old. Need #{REQUIRED_VERSION}+. Run: brew upgrade nctl"
+    end
+  end
+end

data/lib/deploio/output.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "tty-table"
+require "pastel"
+
+# Utility module for formatted console output
+module Deploio
+  module Output
+    class << self
+      def color_enabled
+        return @color_enabled if defined?(@color_enabled)
+
+        @color_enabled = $stdout.tty?
+      end
+
+      def color_enabled=(value)
+        @color_enabled = value
+        @pastel = nil
+      end
+
+      def success(message)
+        puts pastel.green("✓ #{message}")
+      end
+
+      def error(message)
+        warn pastel.red("✗ #{message}")
+      end
+
+      def warning(message)
+        puts pastel.yellow("! #{message}")
+      end
+
+      def info(message)
+        puts pastel.cyan("→ #{message}")
+      end
+
+      def command(cmd)
+        puts pastel.bold("> #{cmd}")
+      end
+
+      def header(text)
+        puts pastel.magenta.bold(text)
+      end
+
+      def table(rows, headers: nil)
+        return if rows.empty?
+
+        tty_table = headers ? TTY::Table.new(header: headers, rows: rows) : TTY::Table.new(rows: rows)
+        puts tty_table.render(:unicode, padding: [0, 2, 0, 1], width: 10_000)
+      end
+
+      private
+
+      def pastel
+        @pastel ||= Pastel.new(enabled: color_enabled)
+      end
+    end
+  end
+end

data/lib/deploio/shared_options.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Deploio
+  module SharedOptions
+    def self.included(base)
+      base.class_option :app, aliases: "-a", type: :string, desc: "App in <project>-<app> format"
+      base.class_option :org, aliases: "-o", type: :string, desc: "Organization"
+      base.class_option :dry_run, type: :boolean, default: false, desc: "Print commands without executing"
+      base.class_option :no_color, type: :boolean, default: false, desc: "Disable colored output"
+
+      base.define_singleton_method(:exit_on_failure?) { true }
+    end
+
+    private
+
+    # Merges parent CLI options with subcommand options.
+    # Parent options take precedence over subcommand defaults.
+    def merged_options
+      @merged_options ||= options
+        .to_h
+        .merge(parent_options.to_h) { |_key, sub, par| par.nil? ? sub : par }
+        .transform_keys(&:to_sym)
+    end
+
+    def setup_options
+      Output.color_enabled = !merged_options[:no_color] && $stdout.tty?
+      @nctl = NctlClient.new(dry_run: merged_options[:dry_run])
+      @nctl.check_requirements unless merged_options[:dry_run]
+    end
+
+    def resolve_app
+      resolver = AppResolver.new(nctl_client: @nctl)
+      resolver.resolve(app_name: merged_options[:app])
+    rescue Deploio::Error => e
+      Output.error(e.message)
+      exit 1
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+#compdef <%= program_name %> depl
+
+# Zsh completion for <%= program_name %>-cli
+# Auto-generated from Thor command definitions
+# Enable with: eval "$(<%= program_name %> completion)"
+
+# Dynamic completion for organizations
+_<%= program_name %>_orgs_list() {
+  local -a orgs
+  orgs=(${(f)"$(<%= program_name %> orgs --json 2>/dev/null | ruby -rjson -e '
+    data = JSON.parse(STDIN.read) rescue []
+    data.each do |o|
+      name = o["name"] || ""
+      current = o["current"] ? " (current)" : ""
+      puts "#{name}:#{name}#{current}"
+    end
+  ' 2>/dev/null)"})
+
+  if [[ ${#orgs[@]} -gt 0 ]]; then
+    _describe -t orgs 'available organizations' orgs
+  else
+    _message 'organization name'
+  fi
+}
+
+# Dynamic completion for apps
+_<%= program_name %>_apps_list() {
+  local -a apps
+  apps=(${(f)"$(<%= program_name %> apps --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 |a|
+      ns = a.dig("metadata", "namespace") || ""
+      name = a.dig("metadata", "name") || ""
+      project = current_org && ns.start_with?("#{current_org}-") ? ns.delete_prefix("#{current_org}-") : ns
+      short_name = "#{project}-#{name}"
+      puts "#{short_name}:#{project}/#{name}"
+    end
+  ' 2>/dev/null)"})
+
+  if [[ ${#apps[@]} -gt 0 ]]; then
+    _describe -t apps 'available apps' apps
+  else
+    _message 'app (format: project-appname)'
+  fi
+}
+
+<% subcommands.each do |name, commands, class_options| %>
+# <%= name %> subcommand
+_<%= program_name %>_<%= name %>() {
+  local -a <%= name %>_commands
+  <%= name %>_commands=(
+<% commands.each do |cmd_name, desc| -%>
+    '<%= cmd_name %>:<%= escape(desc) %>'
+<% end -%>
+  )
+
+  _arguments -s \
+    '1:<%= name %> command:-><%= name %>_cmd' \
+    '*::<%= name %> args:-><%= name %>_args'
+
+  case "$state" in
+    <%= name %>_cmd)
+      _describe -t commands '<%= name %> commands' <%= name %>_commands
+      ;;
+    <%= name %>_args)
+      case "$words[1]" in
+<% commands.each do |cmd_name, _, options| -%>
+        <%= cmd_name %>)
+          _arguments -s \
+<%= format_options(options, class_options, positional_arg(name, cmd_name)) %>
+          ;;
+<% end -%>
+      esac
+      ;;
+  esac
+}
+<% end %>
+
+# Main completion function
+_<%= program_name %>() {
+  local -a main_commands
+  main_commands=(
+<% main_commands.each do |name, desc| -%>
+    '<%= name %>:<%= escape(desc) %>'
+<% end -%>
+  )
+
+  _arguments -s \
+    '(-v --version)'{-v,--version}'[Show version]' \
+    '1:command:->cmd' \
+    '*::command args:->args'
+
+  case "$state" in
+    cmd)
+      _describe -t commands '<%= program_name %> commands' main_commands
+      ;;
+    args)
+      case "$words[1]" in
+<% subcommands.each do |name, _, _| -%>
+        <%= name %>)
+          _<%= program_name %>_<%= name %>
+          ;;
+<% end -%>
+<% direct_commands.each do |cmd_name, options| -%>
+        <%= cmd_name %>)
+          _arguments -s \
+<%= format_options(options, cli_class_options) %>
+          ;;
+<% end -%>
+<% passthrough_commands.each do |cmd_name, options| -%>
+        <%= cmd_name %>)
+          _arguments -s \
+<%= format_options(options, cli_class_options, "'*:command:_normal'") %>
+          ;;
+<% end -%>
+      esac
+      ;;
+  esac
+}
+
+# Register the completion function
+compdef _<%= program_name %> <%= program_name %> depl

data/lib/deploio/utils.rb

@@ -0,0 +1,12 @@
+module Deploio
+  module Utils
+    #  fetches the git remote of origin in the current directory
+    # This is used in different places to auto-detect the app based on the current git remote ala heroku.
+    def self.detect_git_remote
+      stdout, _stderr, status = Open3.capture3("git", "remote", "get-url", "origin")
+      status.success? ? stdout.strip : nil
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/deploio/version.rb

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

data/lib/deploio.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "deploio/version"
+require_relative "deploio/utils"
+require_relative "deploio/output"
+require_relative "deploio/app_ref"
+require_relative "deploio/nctl_client"
+require_relative "deploio/app_resolver"
+require_relative "deploio/shared_options"
+require_relative "deploio/cli"
+
+module Deploio
+  class Error < StandardError; end
+  class AppNotFoundError < Error; end
+  class NctlError < Error; end
+end