kdep 0.1.0

data/lib/kdep/commands/status.rb

@@ -0,0 +1,187 @@
+require "optparse"
+require "time"
+
+module Kdep
+  module Commands
+    class Status
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep status [deploy]"
+          opts.separator ""
+          opts.separator "Shows pod status, image versions, and resource usage."
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new(color: false)
+      end
+
+      def execute
+        deploy_name = @args[0]
+
+        # Discover kdep/ directory
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        # Resolve deploy directory
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        # Load config
+        config = Kdep::Config.new(deploy_dir, nil).load
+
+        # Validate context
+        Kdep::ContextGuard.new(config["context"]).validate!
+
+        # Get pods
+        namespace = config["namespace"]
+        app_name = config["name"]
+        data = Kdep::Kubectl.run_json("get", "pods", "-n", namespace, "-l", "app=#{app_name}")
+        pods = data["items"]
+
+        if pods.nil? || pods.empty?
+          @ui.info("No pods found for #{app_name} in #{namespace}")
+          return
+        end
+
+        # Try to get pod metrics
+        metrics = fetch_pod_metrics(namespace, app_name)
+
+        # Build and display table
+        display_pod_table(pods, metrics)
+
+        # Show replica summary
+        running = pods.count { |p| p["status"]["phase"] == "Running" }
+        total = pods.length
+        @ui.info("Replicas: #{running}/#{total} ready")
+
+        # Cluster health check
+        begin
+          health = Kdep::ClusterHealth.new
+          health.report(@ui)
+        rescue NameError
+          # ClusterHealth not yet implemented, skip
+        end
+      end
+
+      private
+
+      def fetch_pod_metrics(namespace, app_name)
+        begin
+          output = Kdep::Kubectl.run("top", "pods", "-n", namespace, "-l", "app=#{app_name}", "--no-headers")
+          metrics = {}
+          output.each_line do |line|
+            parts = line.strip.split(/\s+/)
+            next if parts.length < 3
+            # name, cpu, memory
+            metrics[parts[0]] = { "cpu" => parts[1], "memory" => parts[2] }
+          end
+          metrics
+        rescue Kdep::Kubectl::Error
+          nil
+        end
+      end
+
+      def display_pod_table(pods, metrics)
+        rows = pods.map do |pod|
+          name = pod["metadata"]["name"]
+          phase = pod["status"]["phase"]
+          containers = pod["status"]["containerStatuses"] || []
+          ready_count = containers.count { |c| c["ready"] }
+          total_count = containers.length
+          ready_str = "#{ready_count}/#{total_count}"
+          restarts = containers.inject(0) { |sum, c| sum + (c["restartCount"] || 0) }
+          image = (pod["spec"]["containers"][0] || {})["image"] || ""
+          # Strip registry prefix for readability (keep last two segments)
+          image_short = image.include?("/") ? image.split("/").last : image
+          age = format_age(pod["metadata"]["creationTimestamp"])
+
+          row = { name: name, status: phase, ready: ready_str, restarts: restarts.to_s, image: image_short, age: age }
+          if metrics && metrics[name]
+            row[:cpu] = metrics[name]["cpu"]
+            row[:memory] = metrics[name]["memory"]
+          end
+          row
+        end
+
+        has_metrics = metrics && rows.any? { |r| r[:cpu] }
+
+        # Calculate column widths
+        headers = [:name, :status, :ready, :restarts, :image, :age]
+        labels = { name: "POD", status: "STATUS", ready: "READY", restarts: "RESTARTS", image: "IMAGE", age: "AGE" }
+
+        if has_metrics
+          headers += [:cpu, :memory]
+          labels[:cpu] = "CPU"
+          labels[:memory] = "MEM"
+        end
+
+        widths = {}
+        headers.each do |h|
+          col_values = rows.map { |r| (r[h] || "").to_s }
+          widths[h] = ([labels[h].length] + col_values.map(&:length)).max
+        end
+
+        # Print header
+        header_line = headers.map { |h| labels[h].ljust(widths[h]) }.join("  ")
+        @ui.info(header_line)
+
+        # Print rows
+        rows.each do |row|
+          line = headers.map { |h| (row[h] || "").to_s.ljust(widths[h]) }.join("  ")
+          @ui.info(line)
+        end
+      end
+
+      def format_age(timestamp)
+        return "?" unless timestamp
+        created = Time.parse(timestamp)
+        diff = Time.now - created
+        if diff >= 86400
+          "#{(diff / 86400).to_i}d"
+        elsif diff >= 3600
+          "#{(diff / 3600).to_i}h"
+        elsif diff >= 60
+          "#{(diff / 60).to_i}m"
+        else
+          "#{diff.to_i}s"
+        end
+      end
+
+      def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        if deploy_name
+          deploy_dir = File.join(kdep_dir, deploy_name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy target not found: #{deploy_name}")
+            deploys = discovery.find_deploys
+            if deploys.any?
+              @ui.info("Available deploys: #{deploys.join(', ')}")
+            end
+            return nil
+          end
+          deploy_dir
+        else
+          deploys = discovery.find_deploys
+          if deploys.length == 1
+            File.join(kdep_dir, deploys[0])
+          elsif deploys.length > 1
+            @ui.error("Multiple deploys found, specify one: #{deploys.join(', ')}")
+            nil
+          else
+            @ui.error("No deploy targets found in kdep/")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kdep/config.rb

@@ -0,0 +1,69 @@
+require "yaml"
+
+module Kdep
+  class Config
+    attr_reader :deploy_dir, :env
+
+    def initialize(deploy_dir, env = nil)
+      @deploy_dir = deploy_dir
+      @env = env
+    end
+
+    def load
+      base = load_yaml(File.join(@deploy_dir, "app.yml"))
+
+      if @env
+        overlay_path = File.join(@deploy_dir, "app_#{@env}.yml")
+        if File.exist?(overlay_path)
+          overlay = load_yaml(overlay_path)
+          base = deep_merge(base, overlay)
+        end
+      end
+
+      apply_defaults(base)
+    end
+
+    def deep_merge(base, overlay)
+      base.merge(overlay) do |_key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+
+    private
+
+    def load_yaml(path)
+      content = File.read(path)
+      if RUBY_VERSION >= "3.1"
+        YAML.safe_load(content, permitted_classes: [], permitted_symbols: [], aliases: false, filename: path) || {}
+      else
+        YAML.safe_load(content, [], [], false, path) || {}
+      end
+    end
+
+    def apply_defaults(config)
+      preset_name = config.fetch("preset", "custom")
+      defaults = Kdep::Defaults.for_preset(preset_name)
+      result = deep_merge(defaults, config)
+
+      # Name default: derive from project folder + deploy folder name
+      # deploy_dir is [project]/kdep/[deploy], so go up 2 levels for project name
+      unless result.key?("name")
+        deploy = File.basename(@deploy_dir)
+        kdep_dir = File.dirname(@deploy_dir)
+        project = File.basename(File.dirname(kdep_dir))
+        result["name"] = "#{project}-#{deploy}"
+      end
+
+      # Image default: use name value
+      unless result.key?("image")
+        result["image"] = result["name"]
+      end
+
+      result
+    end
+  end
+end

data/lib/kdep/context_guard.rb

@@ -0,0 +1,23 @@
+module Kdep
+  class ContextGuard
+    def initialize(expected_context)
+      @expected_context = expected_context
+      @ui = Kdep::UI.new(color: false)
+    end
+
+    def validate!
+      if @expected_context.nil? || @expected_context.to_s.strip.empty?
+        @ui.warn("No context specified in app.yml -- skipping context validation. Add 'context: your-cluster' for safety.")
+        return
+      end
+
+      actual = Kdep::Kubectl.current_context
+      return if actual == @expected_context
+
+      raise Kdep::Kubectl::Error,
+        "Context mismatch: kubectl is set to '#{actual}' but app.yml expects '#{@expected_context}'. " \
+        "Aborting to prevent wrong-cluster deployment. " \
+        "Run: kubectl config use-context #{@expected_context}"
+    end
+  end
+end

data/lib/kdep/dashboard/health_panel.rb

@@ -0,0 +1,53 @@
+module Kdep
+  class Dashboard
+    class HealthPanel < Panel
+      CPU_WARN    = 80
+      MEMORY_WARN = 85
+
+      GREEN  = "\e[32m".freeze
+      YELLOW = "\e[33m".freeze
+      RESET  = "\e[0m".freeze
+
+      def update(node_data)
+        @node_data = node_data
+        build_lines
+      end
+
+      private
+
+      def build_lines
+        content = []
+        has_warning = false
+
+        (@node_data || []).each do |node|
+          name = node[:name] || node["name"]
+          cpu = node[:cpu_percent] || node["cpu_percent"]
+          mem = node[:mem_percent] || node["mem_percent"]
+
+          cpu_warn = cpu.to_i > CPU_WARN
+          mem_warn = mem.to_i > MEMORY_WARN
+          has_warning = true if cpu_warn || mem_warn
+
+          cpu_str = cpu_warn ? "#{YELLOW}#{cpu}%#{RESET}" : "#{cpu}%"
+          mem_str = mem_warn ? "#{YELLOW}#{mem}%#{RESET}" : "#{mem}%"
+
+          content << "#{name}  CPU: #{cpu_str}  MEM: #{mem_str}"
+        end
+
+        unless has_warning
+          content << "#{GREEN}Cluster healthy#{RESET}"
+        end
+
+        @lines = content
+        clamp_scroll_offset
+      end
+
+      def clamp_scroll_offset
+        content_height = @rect.height - 2
+        max = [@lines.length - content_height, 0].max
+        @scroll_offset = [@scroll_offset, max].min
+        @scroll_offset = [@scroll_offset, 0].max
+      end
+    end
+  end
+end

data/lib/kdep/dashboard/layout.rb

@@ -0,0 +1,40 @@
+module Kdep
+  class Dashboard
+    Rect = Struct.new(:top, :left, :height, :width)
+
+    class Layout
+      MIN_ROWS = 16
+      MIN_COLS = 60
+
+      def initialize(rows:, cols:)
+        @rows = rows
+        @cols = cols
+      end
+
+      def panels
+        return nil if @rows < MIN_ROWS || @cols < MIN_COLS
+
+        # Reserve row 0 for header, last row for status bar
+        usable_top = 1
+        usable_height = @rows - 2  # minus header and status bar
+        usable_left = 0
+        usable_width = @cols
+
+        top_height = usable_height / 2
+        bottom_height = usable_height - top_height
+
+        left_width = (usable_width * 0.6).to_i
+        right_width = usable_width - left_width
+
+        bottom_top = usable_top + top_height
+
+        {
+          rollout:   Rect.new(usable_top, usable_left, top_height, left_width),
+          resources: Rect.new(usable_top, usable_left + left_width, top_height, right_width),
+          logs:      Rect.new(bottom_top, usable_left, bottom_height, left_width),
+          health:    Rect.new(bottom_top, usable_left + left_width, bottom_height, right_width),
+        }
+      end
+    end
+  end
+end

data/lib/kdep/dashboard/log_panel.rb

@@ -0,0 +1,54 @@
+module Kdep
+  class Dashboard
+    class LogPanel < Panel
+      MAX_LINES = 500
+
+      ERROR_PATTERN = /\b(ERROR|FATAL|PANIC)\b/
+      WARN_PATTERN  = /\b(WARN|WARNING)\b/
+
+      RED    = "\e[31m".freeze
+      YELLOW = "\e[33m".freeze
+      RESET  = "\e[0m".freeze
+
+      def add_line(line)
+        was_at_bottom = at_bottom?
+
+        highlighted = highlight(line)
+        @lines << highlighted
+
+        # Cap buffer at MAX_LINES
+        while @lines.length > MAX_LINES
+          @lines.shift
+        end
+
+        # Auto-scroll to bottom if we were at bottom
+        if was_at_bottom
+          scroll_to_bottom
+        end
+      end
+
+      private
+
+      def highlight(line)
+        if line.match?(ERROR_PATTERN)
+          "#{RED}#{line}#{RESET}"
+        elsif line.match?(WARN_PATTERN)
+          "#{YELLOW}#{line}#{RESET}"
+        else
+          line
+        end
+      end
+
+      def at_bottom?
+        content_height = @rect.height - 2
+        max_offset = [@lines.length - content_height, 0].max
+        @scroll_offset >= max_offset
+      end
+
+      def scroll_to_bottom
+        content_height = @rect.height - 2
+        @scroll_offset = [@lines.length - content_height, 0].max
+      end
+    end
+  end
+end

data/lib/kdep/dashboard/panel.rb

@@ -0,0 +1,135 @@
+module Kdep
+  class Dashboard
+    class Panel
+      attr_reader :title, :rect, :lines, :scroll_offset
+
+      def initialize(title:, rect:)
+        @title = title
+        @rect = rect
+        @lines = []
+        @scroll_offset = 0
+      end
+
+      def update(lines)
+        @lines = lines.dup
+        clamp_scroll
+      end
+
+      def add_line(line)
+        @lines << line
+      end
+
+      def scroll_up
+        @scroll_offset = [@scroll_offset - 1, 0].max
+      end
+
+      def scroll_down
+        max = [visible_line_count, 0].max
+        @scroll_offset = [@scroll_offset + 1, max].min
+      end
+
+      def render
+        output = []
+        w = @rect.width
+
+        # Title bar
+        title_text = " #{@title} "
+        bar_width = [w - 2, 0].max
+        if title_text.length > bar_width
+          title_text = title_text[0, bar_width]
+        end
+        dashes = bar_width - title_text.length
+        left_dashes = dashes / 2
+        right_dashes = dashes - left_dashes
+        output << "+" + ("-" * left_dashes) + title_text + ("-" * right_dashes) + "+"
+
+        # Content area
+        content_height = @rect.height - 2  # minus title and bottom border
+        content_width = [w - 4, 0].max  # minus "| " and " |"
+
+        visible = content_lines
+        content_height.times do |i|
+          line = visible[i] || ""
+          # Strip ANSI for length calculation, but keep ANSI in output
+          display_len = strip_ansi(line).length
+          if display_len > content_width
+            line = truncate_with_ansi(line, content_width)
+          elsif display_len < content_width
+            line = line + (" " * (content_width - display_len))
+          end
+          output << "| " + line + " |"
+        end
+
+        # Bottom border
+        output << "+" + ("-" * bar_width) + "+"
+
+        output
+      end
+
+      protected
+
+      def content_lines
+        content_height = @rect.height - 2
+        max_offset = [@lines.length - content_height, 0].max
+        offset = [@scroll_offset, max_offset].min
+        @lines[offset, content_height] || []
+      end
+
+      def visible_line_count
+        content_height = @rect.height - 2
+        [@lines.length - content_height, 0].max
+      end
+
+      def strip_ansi(str)
+        str.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def truncate_with_ansi(str, max_width)
+        visible = 0
+        i = 0
+        result = ""
+        while i < str.length && visible < max_width
+          if str[i] == "\e"
+            # Consume ANSI sequence
+            seq_end = str.index("m", i)
+            if seq_end
+              result << str[i..seq_end]
+              i = seq_end + 1
+            else
+              result << str[i]
+              i += 1
+              visible += 1
+            end
+          else
+            result << str[i]
+            i += 1
+            visible += 1
+          end
+        end
+        # Append any remaining ANSI sequences (like reset)
+        while i < str.length
+          if str[i] == "\e"
+            seq_end = str.index("m", i)
+            if seq_end
+              result << str[i..seq_end]
+              i = seq_end + 1
+            else
+              break
+            end
+          else
+            break
+          end
+        end
+        result
+      end
+
+      private
+
+      def clamp_scroll
+        max = visible_line_count
+        @scroll_offset = [@scroll_offset, max].min
+        @scroll_offset = [@scroll_offset, 0].max
+      end
+    end
+  end
+end

data/lib/kdep/dashboard/resources_panel.rb

@@ -0,0 +1,91 @@
+module Kdep
+  class Dashboard
+    class ResourcesPanel < Panel
+      WARN_THRESHOLD = 80
+      CRIT_THRESHOLD = 95
+
+      RED    = "\e[31m".freeze
+      YELLOW = "\e[33m".freeze
+      RESET  = "\e[0m".freeze
+
+      def update(metrics)
+        @pod_metrics = metrics
+        build_lines
+      end
+
+      private
+
+      def build_lines
+        content = []
+        content << "POD                    CPU           MEM"
+        content << "-" * 42
+
+        (@pod_metrics || []).each do |pod|
+          name = pod[:name] || pod["name"]
+          cpu = pod[:cpu] || pod["cpu"]
+          cpu_limit = pod[:cpu_limit] || pod["cpu_limit"]
+          memory = pod[:memory] || pod["memory"]
+          mem_limit = pod[:mem_limit] || pod["mem_limit"]
+
+          cpu_pct = calc_percent_milli(cpu, cpu_limit)
+          mem_pct = calc_percent_mem(memory, mem_limit)
+
+          cpu_str = colorize_value("#{cpu}/#{cpu_limit}", cpu_pct)
+          mem_str = colorize_value("#{memory}/#{mem_limit}", mem_pct)
+
+          content << "%-22s %s  %s" % [name, cpu_str, mem_str]
+        end
+
+        # Use the parent's update to set @lines
+        @lines = content
+        clamp_scroll_offset
+      end
+
+      def calc_percent_milli(value, limit)
+        return 0 unless value && limit
+        v = value.to_s.sub(/m$/, "").to_f
+        l = limit.to_s.sub(/m$/, "").to_f
+        return 0 if l <= 0
+        (v / l * 100).to_i
+      end
+
+      def calc_percent_mem(value, limit)
+        return 0 unless value && limit
+        v = parse_mem(value.to_s)
+        l = parse_mem(limit.to_s)
+        return 0 if l <= 0
+        (v.to_f / l * 100).to_i
+      end
+
+      def parse_mem(str)
+        case str
+        when /^(\d+(?:\.\d+)?)Gi$/
+          $1.to_f * 1024
+        when /^(\d+(?:\.\d+)?)Mi$/
+          $1.to_f
+        when /^(\d+(?:\.\d+)?)Ki$/
+          $1.to_f / 1024
+        else
+          str.to_f
+        end
+      end
+
+      def colorize_value(str, percent)
+        if percent >= CRIT_THRESHOLD
+          "#{RED}#{str}#{RESET}"
+        elsif percent >= WARN_THRESHOLD
+          "#{YELLOW}#{str}#{RESET}"
+        else
+          str
+        end
+      end
+
+      def clamp_scroll_offset
+        content_height = @rect.height - 2
+        max = [@lines.length - content_height, 0].max
+        @scroll_offset = [@scroll_offset, max].min
+        @scroll_offset = [@scroll_offset, 0].max
+      end
+    end
+  end
+end