kdep 0.1.0

data/lib/kdep/dashboard/rollout_panel.rb

@@ -0,0 +1,75 @@
+module Kdep
+  class Dashboard
+    class RolloutPanel < Panel
+      def update_from_deployment(deployment_json)
+        spec = deployment_json["spec"] || {}
+        status = deployment_json["status"] || {}
+
+        desired = spec["replicas"] || 1
+        updated = status["updatedReplicas"] || 0
+        available = status["availableReplicas"] || 0
+        ready = status["readyReplicas"] || 0
+
+        percent = desired > 0 ? (updated * 100 / desired) : 0
+
+        conditions = status["conditions"] || []
+        progressing = conditions.find { |c| c["type"] == "Progressing" }
+        failed = progressing && progressing["status"] == "False"
+        message = progressing ? progressing["message"] : nil
+
+        @rollout = {
+          desired: desired,
+          updated: updated,
+          available: available,
+          ready: ready,
+          percent: percent,
+          failed: failed,
+          message: message,
+        }
+
+        build_lines
+      end
+
+      private
+
+      def build_lines
+        return unless @rollout
+
+        content = []
+        percent = @rollout[:percent]
+        bar_width = [rect.width - 20, 10].max
+        bar = render_progress_bar(percent, bar_width)
+
+        if @rollout[:failed]
+          content << "\e[31mRollout: #{percent}% #{bar}\e[0m"
+        elsif percent >= 100
+          content << "\e[32mRollout: 100% #{bar}\e[0m"
+          content << "\e[32mRollout complete\e[0m"
+        else
+          content << "Rollout: #{percent}% #{bar}"
+        end
+
+        d = @rollout[:desired]
+        content << "Pods: #{@rollout[:updated]}/#{d} updated, #{@rollout[:available]}/#{d} available, #{@rollout[:ready]}/#{d} ready"
+
+        if @rollout[:failed] && @rollout[:message]
+          content << "\e[31m#{@rollout[:message]}\e[0m"
+        end
+
+        update(content)
+      end
+
+      def render_progress_bar(percent, width)
+        filled = (width * percent / 100.0).to_i
+        bar = "=" * [filled, 0].max
+        if filled < width && filled > 0
+          bar += ">"
+          space = " " * [width - filled - 1, 0].max
+        else
+          space = " " * [width - filled, 0].max
+        end
+        "[#{bar}#{space}] #{percent}%"
+      end
+    end
+  end
+end

data/lib/kdep/dashboard/screen.rb

@@ -0,0 +1,29 @@
+module Kdep
+  class Dashboard
+    module Screen
+      ENTER_ALT    = "\e[?1049h".freeze
+      EXIT_ALT     = "\e[?1049l".freeze
+      HIDE_CURSOR  = "\e[?25l".freeze
+      SHOW_CURSOR  = "\e[?25h".freeze
+      CLEAR_SCREEN = "\e[2J".freeze
+      HOME         = "\e[H".freeze
+      CLEAR_LINE_SEQ = "\e[2K".freeze
+
+      def self.enter_sequence
+        ENTER_ALT + HIDE_CURSOR + CLEAR_SCREEN + HOME
+      end
+
+      def self.exit_sequence
+        SHOW_CURSOR + EXIT_ALT
+      end
+
+      def self.move_to(row, col)
+        "\e[#{row};#{col}H"
+      end
+
+      def self.clear_line
+        CLEAR_LINE_SEQ
+      end
+    end
+  end
+end

data/lib/kdep/dashboard.rb

@@ -0,0 +1,258 @@
+require "io/console"
+require "kdep/dashboard/screen"
+require "kdep/dashboard/layout"
+require "kdep/dashboard/panel"
+require "kdep/dashboard/rollout_panel"
+require "kdep/dashboard/log_panel"
+require "kdep/dashboard/resources_panel"
+require "kdep/dashboard/health_panel"
+require "kdep/kubectl"
+
+module Kdep
+  class Dashboard
+    PANEL_ORDER = [:rollout, :logs, :resources, :health].freeze
+    PANEL_NAMES = { rollout: "Rollout", logs: "Logs", resources: "Resources", health: "Health" }.freeze
+    REFRESH_INTERVAL = 0.25
+
+    def initialize(config)
+      @config = config
+      @name = config["name"]
+      @namespace = config["namespace"] || "default"
+      @deployment_name = config["deployment_name"] || @name
+      @panels = {}
+      @active_panel = :rollout
+      @quit = false
+      @running = false
+      @threads = []
+      @ios = []
+      @mutex = Mutex.new
+    end
+
+    def run
+      unless $stdout.tty?
+        puts "Dashboard skipped: not a TTY"
+        return
+      end
+
+      rows, cols = IO.console.winsize
+      return if init_panels(rows, cols).nil?
+
+      $stdout.print Screen.enter_sequence
+      $stdout.flush
+      @running = true
+      @quit = false
+
+      setup_signal_handlers
+      start_log_thread
+      start_rollout_thread
+      start_metrics_thread
+
+      begin
+        $stdin.raw do |raw_stdin|
+          until @quit
+            if IO.select([raw_stdin], nil, nil, 0)
+              key = raw_stdin.getc
+              handle_key(key) if key
+            end
+            break if @quit
+            render_all_panels($stdout, rows, cols)
+            sleep REFRESH_INTERVAL
+          end
+        end
+      ensure
+        stop_data_threads
+        $stdout.print Screen.exit_sequence
+        $stdout.flush
+      end
+    end
+
+    private
+
+    def init_panels(rows, cols)
+      layout = Layout.new(rows: rows, cols: cols)
+      rects = layout.panels
+      return nil if rects.nil?
+
+      @panels = {
+        rollout:   RolloutPanel.new(title: "Rollout", rect: rects[:rollout]),
+        logs:      LogPanel.new(title: "Logs", rect: rects[:logs]),
+        resources: ResourcesPanel.new(title: "Resources", rect: rects[:resources]),
+        health:    HealthPanel.new(title: "Health", rect: rects[:health]),
+      }
+      @active_panel = :rollout
+      @panels
+    end
+
+    def handle_key(key)
+      case key
+      when "q"
+        @quit = true
+      when "\x03" # Ctrl+C
+        @quit = true
+      when "\t"
+        idx = PANEL_ORDER.index(@active_panel) || 0
+        @active_panel = PANEL_ORDER[(idx + 1) % PANEL_ORDER.length]
+      when "j"
+        @mutex.synchronize { @panels[@active_panel].scroll_down }
+      when "k"
+        @mutex.synchronize { @panels[@active_panel].scroll_up }
+      when "1"
+        @active_panel = :rollout
+      when "2"
+        @active_panel = :logs
+      when "3"
+        @active_panel = :resources
+      when "4"
+        @active_panel = :health
+      end
+    end
+
+    def setup_signal_handlers
+      Signal.trap("INT") { @quit = true }
+      Signal.trap("TERM") { @quit = true }
+    end
+
+    def render_all_panels(io, rows, cols)
+      buf = ""
+
+      # Header
+      header = "kdep dashboard -- #{@name} (ns: #{@namespace}) -- q:quit tab:switch j/k:scroll"
+      if header.length > cols
+        header = header[0, cols]
+      end
+      buf << Screen.move_to(1, 1) << Screen.clear_line << header
+
+      # Panels
+      @mutex.synchronize do
+        @panels.each do |name, panel|
+          rect = panel.rect
+          lines = panel.render
+
+          # Highlight active panel border
+          lines.each_with_index do |line, i|
+            buf << Screen.move_to(rect.top + i + 1, rect.left + 1) << line
+          end
+        end
+      end
+
+      # Status bar
+      active_name = PANEL_NAMES[@active_panel] || @active_panel.to_s
+      status = " Active: #{active_name} | Refreshing..."
+      if status.length > cols
+        status = status[0, cols]
+      end
+      buf << Screen.move_to(rows, 1) << Screen.clear_line << status
+
+      io.print buf
+      io.flush
+    end
+
+    # --- Data threads ---
+
+    def start_log_thread
+      t = Thread.new do
+        begin
+          cmd = ["kubectl", "logs", "-n", @namespace, "-l", "app=#{@name}",
+                 "-f", "--tail=50", "--all-containers", "--prefix"]
+          io = IO.popen(cmd, "r", err: [:child, :out])
+          @mutex.synchronize { @ios << io }
+          while @running && (line = io.gets)
+            @mutex.synchronize { @panels[:logs].add_line(line.chomp) }
+          end
+        rescue => e
+          @mutex.synchronize { @panels[:logs].add_line("Log stream error: #{e.message}") } if @running
+        ensure
+          io.close if io && !io.closed?
+        end
+      end
+      @threads << t
+    end
+
+    def start_rollout_thread
+      t = Thread.new do
+        interval = 2
+        while @running
+          begin
+            data = Kdep::Kubectl.run_json("get", "deployment", @deployment_name, "-n", @namespace)
+            @mutex.synchronize { @panels[:rollout].update_from_deployment(data) }
+            interval = 2
+          rescue => e
+            @mutex.synchronize { @panels[:rollout].add_line("Error: #{e.message}") } if @running
+            interval = 5
+          end
+          sleep_interruptible(interval)
+        end
+      end
+      @threads << t
+    end
+
+    def start_metrics_thread
+      t = Thread.new do
+        while @running
+          begin
+            # Pod metrics
+            pod_output = Kdep::Kubectl.run("top", "pods", "-n", @namespace, "-l", "app=#{@name}", "--no-headers")
+            pod_metrics = parse_pod_metrics(pod_output)
+            @mutex.synchronize { @panels[:resources].update(pod_metrics) }
+          rescue => e
+            @mutex.synchronize { @panels[:resources].add_line("Error: #{e.message}") } if @running
+          end
+
+          begin
+            # Node metrics
+            node_output = Kdep::Kubectl.run("top", "nodes", "--no-headers")
+            node_data = parse_node_metrics(node_output)
+            @mutex.synchronize { @panels[:health].update(node_data) }
+          rescue => e
+            @mutex.synchronize { @panels[:health].add_line("Error: #{e.message}") } if @running
+          end
+
+          sleep_interruptible(5)
+        end
+      end
+      @threads << t
+    end
+
+    def sleep_interruptible(seconds)
+      elapsed = 0
+      while elapsed < seconds && @running
+        sleep 0.5
+        elapsed += 0.5
+      end
+    end
+
+    def stop_data_threads
+      @running = false
+
+      @threads.each do |t|
+        t.join(2)
+        t.kill if t.alive?
+      end
+
+      @ios.each do |io|
+        io.close unless io.closed?
+      rescue
+        # ignore close errors
+      end
+
+      @threads.clear
+      @ios.clear
+    end
+
+    def parse_pod_metrics(output)
+      output.lines.map do |line|
+        parts = line.strip.split(/\s+/)
+        next if parts.length < 3
+        { name: parts[0], cpu: parts[1], memory: parts[2] }
+      end.compact
+    end
+
+    def parse_node_metrics(output)
+      output.lines.map do |line|
+        parts = line.strip.split(/\s+/)
+        next if parts.length < 5
+        { name: parts[0], cpu_percent: parts[2].to_s.sub(/%$/, ""), mem_percent: parts[4].to_s.sub(/%$/, "") }
+      end.compact
+    end
+  end
+end

data/lib/kdep/defaults.rb

@@ -0,0 +1,21 @@
+module Kdep
+  module Defaults
+    BASE_DEFAULTS = {
+      "port" => 8080,
+      "replicas" => 1,
+    }.freeze
+
+    PRESET_OVERRIDES = {
+      "web"     => { "replicas" => 3 },
+      "worker"  => {},
+      "job"     => {},
+      "cronjob" => {},
+      "custom"  => {},
+    }.freeze
+
+    def self.for_preset(preset_name)
+      overrides = PRESET_OVERRIDES.fetch(preset_name, {})
+      BASE_DEFAULTS.merge(overrides)
+    end
+  end
+end

data/lib/kdep/discovery.rb

@@ -0,0 +1,29 @@
+module Kdep
+  class Discovery
+    def initialize(start_dir = Dir.pwd)
+      @start_dir = start_dir
+    end
+
+    def find_kdep_dir
+      dir = @start_dir
+      loop do
+        candidate = File.join(dir, "kdep")
+        return candidate if File.directory?(candidate)
+        parent = File.dirname(dir)
+        break if parent == dir # reached filesystem root
+        dir = parent
+      end
+      nil
+    end
+
+    def find_deploys
+      kdep_dir = find_kdep_dir
+      return [] unless kdep_dir
+
+      Dir.entries(kdep_dir)
+         .select { |e| File.directory?(File.join(kdep_dir, e)) }
+         .reject { |e| e.start_with?(".") }
+         .sort
+    end
+  end
+end

data/lib/kdep/docker.rb

@@ -0,0 +1,29 @@
+require "open3"
+
+module Kdep
+  module Docker
+    class Error < StandardError; end
+
+    def self.build(tag:, context_dir:, dockerfile: nil, target: nil, platform: nil)
+      args = ["docker", "build", "-t", tag]
+      args.push("--file", dockerfile) if dockerfile
+      args.push("--target", target) if target
+      args.push("--platform", platform) if platform
+      args.push(context_dir)
+
+      stdout, stderr, status = Open3.capture3(*args)
+      unless status.success?
+        raise Error, "docker build failed: #{stderr.strip}"
+      end
+      stdout
+    end
+
+    def self.push(tag)
+      stdout, stderr, status = Open3.capture3("docker", "push", tag)
+      unless status.success?
+        raise Error, "docker push failed: #{stderr.strip}"
+      end
+      stdout
+    end
+  end
+end

data/lib/kdep/kubectl.rb

@@ -0,0 +1,41 @@
+require "open3"
+require "json"
+
+module Kdep
+  module Kubectl
+    class Error < StandardError; end
+
+    def self.run(*args)
+      stdout, stderr, status = Open3.capture3("kubectl", *args)
+      unless status.success?
+        raise Error, "kubectl #{args.first} failed: #{stderr.strip}"
+      end
+      stdout
+    end
+
+    def self.run_json(*args)
+      output = run(*args, "-o", "json")
+      JSON.parse(output)
+    end
+
+    def self.current_context
+      run("config", "current-context").strip
+    end
+
+    def self.apply(file_path, namespace:)
+      run("apply", "-f", file_path, "-n", namespace)
+    end
+
+    def self.diff(file_path)
+      stdout, stderr, status = Open3.capture3("kubectl", "diff", "-f", file_path)
+      case status.exitstatus
+      when 0
+        nil
+      when 1
+        stdout
+      else
+        raise Error, "kubectl diff failed (exit #{status.exitstatus}): #{stderr.strip}"
+      end
+    end
+  end
+end

data/lib/kdep/preset.rb

@@ -0,0 +1,33 @@
+module Kdep
+  class Preset
+    BUILT_IN = %w[web worker job cronjob custom].freeze
+
+    def initialize(preset_name, deploy_dir)
+      @preset_name = preset_name
+      @deploy_dir = deploy_dir
+    end
+
+    def resources
+      path = resolve_preset_path
+      raise "Preset not found: #{@preset_name}" unless path
+
+      File.readlines(path).map(&:strip).reject do |line|
+        line.empty? || line.start_with?("#")
+      end
+    end
+
+    private
+
+    def resolve_preset_path
+      # Check user custom preset first
+      user_path = File.join(@deploy_dir, "presets", @preset_name)
+      return user_path if File.exist?(user_path)
+
+      # Fall back to built-in
+      builtin_path = File.join(Kdep.templates_dir, "presets", @preset_name)
+      return builtin_path if File.exist?(builtin_path)
+
+      nil
+    end
+  end
+end

data/lib/kdep/registry.rb

@@ -0,0 +1,94 @@
+require "net/http"
+require "json"
+require "uri"
+require "base64"
+
+module Kdep
+  class Registry
+    class Error < StandardError; end
+
+    attr_reader :host, :path_prefix
+
+    def initialize(registry_url)
+      url = registry_url.chomp("/")
+      parts = url.split("/", 2)
+      @host = parts[0]
+      @path_prefix = parts[1]
+      @registry_url = url
+    end
+
+    def list_tags(image)
+      repository = "#{@path_prefix}/#{image}"
+      uri = URI("https://#{@host}/v2/#{repository}/tags/list")
+
+      req = Net::HTTP::Get.new(uri)
+      apply_auth(req, repository)
+
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        http.request(req)
+      end
+
+      return [] if response.code == "404"
+
+      unless response.code.start_with?("2")
+        raise Error, "Registry returned #{response.code}: #{response.body}"
+      end
+
+      data = JSON.parse(response.body)
+      data["tags"] || []
+    end
+
+    private
+
+    def apply_auth(request, repository)
+      if @host == "ghcr.io" || @host.end_with?(".ghcr.io")
+        apply_ghcr_auth(request, repository)
+      else
+        apply_docker_config_auth(request)
+      end
+    end
+
+    def apply_ghcr_auth(request, repository)
+      token = ENV["GHCR_TOKEN"]
+      if token && !token.empty?
+        request["Authorization"] = "Bearer #{token}"
+        return
+      end
+
+      begin
+        token_uri = URI("https://ghcr.io/token?scope=repository:#{repository}:pull")
+        token_response = Net::HTTP.start(token_uri.host, token_uri.port, use_ssl: true) do |http|
+          http.request(Net::HTTP::Get.new(token_uri))
+        end
+        if token_response.code.start_with?("2")
+          data = JSON.parse(token_response.body)
+          if data["token"]
+            request["Authorization"] = "Bearer #{data["token"]}"
+          end
+        end
+      rescue StandardError
+        # Gracefully skip if token endpoint fails
+      end
+    end
+
+    def apply_docker_config_auth(request)
+      path = docker_config_path
+      return unless File.exist?(path)
+
+      begin
+        config = JSON.parse(File.read(path))
+        auths = config["auths"] || {}
+        entry = auths[@host]
+        if entry && entry["auth"]
+          request["Authorization"] = "Basic #{entry["auth"]}"
+        end
+      rescue StandardError
+        # Gracefully skip if config parsing fails
+      end
+    end
+
+    def docker_config_path
+      File.join(Dir.home, ".docker", "config.json")
+    end
+  end
+end

data/lib/kdep/renderer.rb

@@ -0,0 +1,53 @@
+require "erb"
+require "yaml"
+
+module Kdep
+  class Renderer
+    def initialize(config, deploy_dir)
+      @config = config
+      @deploy_dir = deploy_dir
+    end
+
+    def render_resource(resource_name)
+      template_path = resolve_template(resource_name)
+      raise "Template not found: #{resource_name}.yml.erb" unless template_path
+
+      template_content = File.read(template_path)
+      erb = if RUBY_VERSION >= "2.6"
+              ERB.new(template_content, trim_mode: "-")
+            else
+              ERB.new(template_content, nil, "-")
+            end
+
+      secrets = {}
+      if resource_name == "secret"
+        secrets = load_secrets
+      end
+
+      context = TemplateContext.new(@config, secrets)
+      erb.result(context.get_binding)
+    end
+
+    private
+
+    def resolve_template(resource_name)
+      # Check user override first
+      user_path = File.join(@deploy_dir, "resources", "#{resource_name}.yml.erb")
+      return user_path if File.exist?(user_path)
+
+      # Fall back to built-in
+      builtin_path = File.join(Kdep.templates_dir, "resources", "#{resource_name}.yml.erb")
+      return builtin_path if File.exist?(builtin_path)
+
+      nil
+    end
+
+    def load_secrets
+      secrets_path = File.join(@deploy_dir, "secrets.yml")
+      return {} unless File.exist?(secrets_path)
+
+      content = File.read(secrets_path)
+      YAML.safe_load(content) || {}
+    end
+  end
+end

data/lib/kdep/template_context.rb

@@ -0,0 +1,22 @@
+module Kdep
+  class TemplateContext
+    def initialize(config, secrets = {})
+      @config = config
+      @secrets = secrets
+
+      # Expose top-level config keys as methods for cleaner templates
+      config.each do |key, value|
+        define_singleton_method(key.to_sym) { value } if key.is_a?(String)
+      end
+    end
+
+    def get_binding
+      binding
+    end
+
+    # Helper: render a value as YAML-safe string
+    def yaml_value(val)
+      val.is_a?(String) ? val : val.to_s
+    end
+  end
+end