kdep 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 701a91c45b5e7323cfedb6347f98a37e53ba7b53e49a5b64804eee71cd7acca5
+  data.tar.gz: 85354c4ac4e4dd599f39a9547ef03403286d61ad6411da1863c4b2eacdc96652
+SHA512:
+  metadata.gz: 290bb09e66a9bc9ecf06e4b4ad248fd292f3560ee7b9e290d3c3186525b541337cf1a0a7d365df4b6fc547c2e54419dbec62a1dc5fa476ced0573f662c461959
+  data.tar.gz: e3a51471ee31d298e1a8849893576e0744de593a9b7ad761bef06ac90814553e3c29249102ab0cf85d52a79a0b2dc76a2bd86e0221fcbf3bf84112a3bf5065d1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Leadfy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/exe/kdep

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "kdep"
+Kdep::CLI.new(ARGV).run

data/lib/kdep/cli.rb

@@ -0,0 +1,72 @@
+require "optparse"
+
+module Kdep
+  class CLI
+    COMMANDS = {
+      "render" => Commands::Render,
+      "init"   => Commands::Init,
+      "eject"  => Commands::Eject,
+      "apply"  => Commands::Apply,
+      "diff"   => Commands::Diff,
+      "status" => Commands::Status,
+      "build"  => Commands::Build,
+      "push"   => Commands::Push,
+      "bump"   => Commands::Bump,
+      "log"    => Commands::Log,
+      "sh"      => Commands::Sh,
+      "secrets" => Commands::Secrets,
+      "restart" => Commands::Restart,
+      "scale"   => Commands::Scale,
+    }.freeze
+
+    def initialize(argv)
+      @argv = argv.dup
+      @global_options = {}
+    end
+
+    def run
+      global_parser.order!(@argv, into: @global_options)
+      command_name = @argv.shift
+
+      if command_name.nil?
+        puts global_parser
+        exit 0
+      end
+
+      unless COMMANDS.key?(command_name)
+        $stderr.puts "Unknown command: #{command_name}"
+        puts global_parser
+        exit 1
+      end
+
+      command_class = COMMANDS[command_name]
+      command_options = {}
+      command_class.option_parser.parse!(@argv, into: command_options)
+      command_class.new(
+        global_options: @global_options,
+        command_options: command_options,
+        args: @argv
+      ).execute
+    end
+
+    private
+
+    def global_parser
+      @global_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: kdep [options] <command> [command-options] [args...]"
+        opts.separator ""
+        opts.separator "Commands: #{COMMANDS.keys.join(', ')}"
+        opts.separator ""
+        opts.separator "Options:"
+        opts.on("-v", "--version", "Show version") do
+          puts Kdep::VERSION
+          exit 0
+        end
+        opts.on("-h", "--help", "Show help") do
+          puts opts
+          exit 0
+        end
+      end
+    end
+  end
+end

data/lib/kdep/cluster_health.rb

@@ -0,0 +1,44 @@
+module Kdep
+  class ClusterHealth
+    CPU_WARN = 80
+    MEMORY_WARN = 85
+
+    def check
+      begin
+        output = Kdep::Kubectl.run("top", "nodes", "--no-headers")
+      rescue Kdep::Kubectl::Error
+        return ["Cluster health metrics unavailable (metrics-server may not be installed)"]
+      end
+
+      warnings = []
+
+      output.each_line do |line|
+        parts = line.strip.split(/\s+/)
+        next if parts.length < 5
+
+        name = parts[0]
+        cpu_percent = parts[2].sub("%", "").to_i
+        mem_percent = parts[4].sub("%", "").to_i
+
+        if cpu_percent > CPU_WARN
+          warnings << "Node #{name}: CPU at #{cpu_percent}% (threshold: #{CPU_WARN}%)"
+        end
+
+        if mem_percent > MEMORY_WARN
+          warnings << "Node #{name}: Memory at #{mem_percent}% (threshold: #{MEMORY_WARN}%)"
+        end
+      end
+
+      warnings
+    end
+
+    def report(ui)
+      warnings = check
+      if warnings.empty?
+        ui.success("Cluster health: OK")
+      else
+        warnings.each { |w| ui.warn(w) }
+      end
+    end
+  end
+end

data/lib/kdep/commands/apply.rb

@@ -0,0 +1,147 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Apply
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep apply [deploy] [env]"
+          opts.separator ""
+          opts.separator "Renders and applies Kubernetes manifests to the cluster."
+          opts.separator ""
+          opts.on("--dry-run", "Show what would be applied without applying")
+        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]
+        env = @args[1]
+
+        # 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, env).load
+
+        # Validate context before any cluster operation
+        begin
+          Kdep::ContextGuard.new(config["context"]).validate!
+        rescue Kdep::Kubectl::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+
+        # Load preset resources and render
+        preset = Kdep::Preset.new(config["preset"], deploy_dir)
+        resources = preset.resources
+
+        repo_root = File.dirname(kdep_dir)
+        output_dir = File.join(repo_root, ".rendered")
+
+        writer = Kdep::Writer.new(output_dir)
+        writer.clean
+        renderer = Kdep::Renderer.new(config, deploy_dir)
+
+        resources.each_with_index do |resource_name, idx|
+          index = idx + 1
+          begin
+            content = renderer.render_resource(resource_name)
+          rescue => e
+            @ui.error("#{resource_name}: #{e.message}")
+            next
+          end
+          writer.write(resource_name, content, index)
+        end
+
+        # Get sorted rendered files
+        rendered_files = Dir.glob(File.join(output_dir, "*.yml")).sort
+
+        if rendered_files.empty?
+          @ui.info("No rendered files to apply")
+          return
+        end
+
+        # Dry run mode
+        if @command_options[:"dry-run"]
+          rendered_files.each do |f|
+            @ui.info("Would apply: #{File.basename(f)}")
+          end
+          @ui.info("#{rendered_files.length} files would be applied (dry-run)")
+          return
+        end
+
+        # Apply each file in order
+        errors = []
+        applied = 0
+
+        namespace = config["namespace"]
+
+        rendered_files.each do |file_path|
+          begin
+            Kdep::Kubectl.apply(file_path, namespace: namespace)
+            @ui.info("applied: #{File.basename(file_path)}")
+            applied += 1
+          rescue Kdep::Kubectl::Error => e
+            errors << { "file" => File.basename(file_path), "error" => e.message }
+            @ui.error("#{File.basename(file_path)}: #{e.message}")
+          end
+        end
+
+        # Summary
+        if errors.empty?
+          @ui.info("#{applied} files applied, 0 errors")
+        else
+          @ui.info("#{applied} files applied, #{errors.length} errors")
+          exit 1
+        end
+      end
+
+      private
+
+      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/commands/build.rb

@@ -0,0 +1,103 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Build
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep build [deploy] [env]"
+          opts.separator ""
+          opts.separator "Builds a Docker image using the deploy configuration."
+          opts.separator ""
+          opts.on("--platform=PLATFORM", "Target platform (e.g., linux/amd64)")
+        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]
+        env = @args[1]
+
+        # 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, env).load
+
+        # Construct full image tag
+        image = config["image"] || config["name"]
+        tag = config["tag"] || "latest"
+        registry = config["registry"]
+
+        if registry && !registry.to_s.empty?
+          full_tag = "#{registry}/#{image}:#{tag}"
+        else
+          full_tag = "#{image}:#{tag}"
+        end
+
+        # Build
+        context_dir = File.dirname(kdep_dir)
+
+        begin
+          Kdep::Docker.build(
+            tag: full_tag,
+            context_dir: context_dir,
+            dockerfile: config["dockerfile"],
+            target: config["target"],
+            platform: @command_options[:platform] || config["platform"]
+          )
+          @ui.info("Built: #{full_tag}")
+        rescue Kdep::Docker::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+      end
+
+      private
+
+      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/commands/bump.rb

@@ -0,0 +1,190 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Bump
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep bump [deploy] [env]"
+          opts.separator ""
+          opts.separator "Full pipeline: registry query -> version increment -> build -> push -> render -> apply."
+          opts.separator ""
+          opts.on("--skip-apply", "Build and push only, skip render+apply")
+          opts.on("--no-dashboard", "Skip TUI dashboard after deploy")
+          opts.on("--platform=PLATFORM", "Target platform (e.g., linux/amd64)")
+        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]
+        env = @args[1]
+
+        # Step 1: Discovery + config
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        deploy_dir = resolve_deploy_dir(kdep_dir, deploy_name, discovery)
+        unless deploy_dir
+          exit 1
+        end
+
+        config = Kdep::Config.new(deploy_dir, env).load
+
+        # Step 2: Context guard (bump touches the cluster)
+        begin
+          Kdep::ContextGuard.new(config["context"]).validate!
+        rescue Kdep::Kubectl::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+
+        image = config["image"] || config["name"]
+        registry_url = config["registry"]
+        repo_root = File.dirname(kdep_dir)
+
+        begin
+          # Step 3: Query registry
+          registry = Kdep::Registry.new(registry_url)
+          tags = registry.list_tags(image)
+          @ui.info("Current tags: #{tags.length} found")
+
+          # Step 4: Increment version
+          next_version = Kdep::VersionTagger.next_tag(tags)
+          @ui.info("Next version: #{next_version}")
+
+          # Step 5: Build
+          if registry_url && !registry_url.to_s.empty?
+            full_tag = "#{registry_url}/#{image}:#{next_version}"
+          else
+            full_tag = "#{image}:#{next_version}"
+          end
+
+          Kdep::Docker.build(
+            tag: full_tag,
+            context_dir: repo_root,
+            dockerfile: config["dockerfile"],
+            target: config["target"],
+            platform: @command_options[:platform] || config["platform"]
+          )
+          @ui.info("Built: #{full_tag}")
+
+          # Step 6: Push
+          Kdep::Docker.push(full_tag)
+          @ui.info("Pushed: #{full_tag}")
+
+          # Step 7: Render + Apply (unless --skip-apply)
+          unless @command_options[:"skip-apply"]
+            config["tag"] = next_version
+
+            # Render manifests
+            preset = Kdep::Preset.new(config["preset"], deploy_dir)
+            resources = preset.resources
+            output_dir = File.join(repo_root, ".rendered")
+
+            writer = Kdep::Writer.new(output_dir)
+            writer.clean
+            renderer = Kdep::Renderer.new(config, deploy_dir)
+
+            resources.each_with_index do |resource_name, idx|
+              index = idx + 1
+              begin
+                content = renderer.render_resource(resource_name)
+              rescue => e
+                @ui.error("#{resource_name}: #{e.message}")
+                next
+              end
+              writer.write(resource_name, content, index)
+            end
+
+            # Apply
+            rendered_files = Dir.glob(File.join(output_dir, "*.yml")).sort
+            namespace = config["namespace"]
+            errors = []
+            applied = 0
+
+            rendered_files.each do |file_path|
+              begin
+                Kdep::Kubectl.apply(file_path, namespace: namespace)
+                @ui.info("applied: #{File.basename(file_path)}")
+                applied += 1
+              rescue Kdep::Kubectl::Error => e
+                errors << { "file" => File.basename(file_path), "error" => e.message }
+                @ui.error("#{File.basename(file_path)}: #{e.message}")
+              end
+            end
+
+            if errors.empty?
+              @ui.info("#{applied} files applied, 0 errors")
+
+              # Launch TUI dashboard for live monitoring
+              unless @command_options[:"no-dashboard"]
+                begin
+                  require "kdep/dashboard"
+                  dashboard = Kdep::Dashboard.new(
+                    "name" => config["name"],
+                    "namespace" => namespace,
+                    "registry" => config["registry"],
+                    "image" => image
+                  )
+                  dashboard.run
+                rescue LoadError, NameError
+                  # Dashboard not available, skip silently
+                end
+              end
+            else
+              @ui.info("#{applied} files applied, #{errors.length} errors")
+              exit 1
+            end
+          end
+
+        rescue Kdep::Docker::Error => e
+          @ui.error(e.message)
+          exit 1
+        rescue Kdep::Registry::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+      end
+
+      private
+
+      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