kdep 0.1.0

data/lib/kdep/commands/diff.rb

@@ -0,0 +1,133 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Diff
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep diff [deploy] [env]"
+          opts.separator ""
+          opts.separator "Shows differences between rendered manifests and live cluster state."
+        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 diff")
+          return
+        end
+
+        # Diff each file against live cluster state
+        has_diffs = false
+        errors = []
+
+        rendered_files.each do |file_path|
+          begin
+            diff_output = Kdep::Kubectl.diff(file_path)
+            if diff_output
+              has_diffs = true
+              @ui.info("--- #{File.basename(file_path)} ---")
+              @ui.info(diff_output)
+            end
+          rescue Kdep::Kubectl::Error => e
+            errors << { "file" => File.basename(file_path), "error" => e.message }
+            @ui.error("#{File.basename(file_path)}: #{e.message}")
+          end
+        end
+
+        unless has_diffs || errors.any?
+          @ui.info("No changes -- cluster state matches rendered manifests.")
+        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/eject.rb

@@ -0,0 +1,97 @@
+require "optparse"
+require "fileutils"
+
+module Kdep
+  module Commands
+    class Eject
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep eject [resource_name]"
+          opts.separator ""
+          opts.separator "Copies a built-in template to your deploy target for customization."
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new
+      end
+
+      def execute
+        resource_name = @args[0]
+
+        if resource_name.nil?
+          list_available_resources
+          return
+        end
+
+        # Find kdep dir
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+
+        unless kdep_dir
+          @ui.error("No kdep/ directory found (run kdep init first)")
+          exit 1
+        end
+
+        # Find deploy directory
+        deploys = discovery.find_deploys
+        if deploys.empty?
+          @ui.error("No deploy targets found in #{kdep_dir}/")
+          exit 1
+        end
+
+        deploy_name = deploys.first
+        deploy_dir = File.join(kdep_dir, deploy_name)
+
+        # Check built-in template exists
+        source = File.join(Kdep.templates_dir, "resources", "#{resource_name}.yml.erb")
+        unless File.exist?(source)
+          @ui.error("Unknown resource: #{resource_name}")
+          @ui.info("Available resources: #{available_resources.join(', ')}")
+          exit 1
+        end
+
+        # Target path
+        resources_dir = File.join(deploy_dir, "resources")
+        target = File.join(resources_dir, "#{resource_name}.yml.erb")
+
+        if File.exist?(target)
+          @ui.warn("#{resource_name}.yml.erb already exists in resources/ -- skipping (delete it first to re-eject)")
+          return
+        end
+
+        # Create resources dir and copy
+        FileUtils.mkdir_p(resources_dir)
+        FileUtils.cp(source, target)
+
+        @ui.file_written(target)
+        @ui.info("Edit #{target} to customize the #{resource_name} template")
+      end
+
+      private
+
+      def list_available_resources
+        resources = available_resources
+        if resources.empty?
+          @ui.info("No built-in resource templates found")
+        else
+          @ui.info("Available resources to eject:")
+          resources.each { |r| @ui.info("  #{r}") }
+        end
+      end
+
+      def available_resources
+        resources_dir = File.join(Kdep.templates_dir, "resources")
+        return [] unless File.directory?(resources_dir)
+
+        Dir.entries(resources_dir)
+           .select { |f| f.end_with?(".yml.erb") }
+           .map { |f| f.sub(".yml.erb", "") }
+           .sort
+      end
+    end
+  end
+end

data/lib/kdep/commands/init.rb

@@ -0,0 +1,99 @@
+require "optparse"
+require "erb"
+require "fileutils"
+
+module Kdep
+  module Commands
+    class Init
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep init [preset] [name]"
+          opts.separator ""
+          opts.separator "Scaffolds a new kdep deploy target."
+          opts.on("--namespace=NAMESPACE", "Kubernetes namespace")
+          opts.on("--registry=REGISTRY", "Container registry URL")
+        end
+      end
+
+      def initialize(global_options:, command_options:, args:)
+        @global_options = global_options
+        @command_options = command_options
+        @args = args
+        @ui = Kdep::UI.new
+      end
+
+      def execute
+        preset = @args[0]
+        deploy_name = @args[1]
+
+        unless preset
+          @ui.error("Missing preset and name arguments")
+          @ui.info("Usage: kdep init [preset] [name]")
+          @ui.info("Available presets: #{Kdep::Preset::BUILT_IN.join(', ')}")
+          exit 1
+        end
+
+        unless deploy_name
+          @ui.error("Missing name argument")
+          @ui.info("Usage: kdep init [preset] [name]")
+          exit 1
+        end
+
+        unless Kdep::Preset::BUILT_IN.include?(preset)
+          @ui.error("Unknown preset: #{preset}")
+          @ui.info("Available presets: #{Kdep::Preset::BUILT_IN.join(', ')}")
+          exit 1
+        end
+
+        target_dir = File.join(Dir.pwd, "kdep", deploy_name)
+
+        if File.exist?(target_dir)
+          @ui.error("kdep/#{deploy_name} already exists")
+          exit 1
+        end
+
+        FileUtils.mkdir_p(target_dir)
+
+        # Render app.yml from ERB template
+        namespace = @command_options[:namespace]
+        registry = @command_options[:registry]
+
+        template_path = File.join(Kdep.templates_dir, "init", "app.yml.erb")
+        template = File.read(template_path)
+        erb = if RUBY_VERSION >= "2.6"
+                ERB.new(template, trim_mode: "-")
+              else
+                ERB.new(template, nil, "-")
+              end
+        binding_ctx = erb_binding(preset: preset, deploy_name: deploy_name,
+                                  namespace: namespace, registry: registry)
+        app_yml_content = erb.result(binding_ctx)
+
+        File.write(File.join(target_dir, "app.yml"), app_yml_content)
+        @ui.file_written("kdep/#{deploy_name}/app.yml")
+
+        # Copy secrets.yml
+        FileUtils.cp(
+          File.join(Kdep.templates_dir, "init", "secrets.yml"),
+          File.join(target_dir, "secrets.yml")
+        )
+        @ui.file_written("kdep/#{deploy_name}/secrets.yml")
+
+        # Copy .gitignore
+        FileUtils.cp(
+          File.join(Kdep.templates_dir, "init", "gitignore"),
+          File.join(target_dir, ".gitignore")
+        )
+        @ui.file_written("kdep/#{deploy_name}/.gitignore")
+
+        @ui.success("Initialized kdep/#{deploy_name} with #{preset} preset")
+      end
+
+      private
+
+      def erb_binding(preset:, deploy_name:, namespace:, registry:)
+        binding
+      end
+    end
+  end
+end

data/lib/kdep/commands/log.rb

@@ -0,0 +1,145 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Log
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep log [deploy]"
+          opts.separator ""
+          opts.separator "Streams pod logs with error highlighting."
+          opts.separator ""
+          opts.on("-f", "--[no-]follow", "Follow log output (default: true)")
+          opts.on("-c", "--container=NAME", "Container name for multi-container pods")
+          opts.on("--tail=N", Integer, "Number of lines to show (default: 100)")
+        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!
+
+        # Find running pod
+        namespace = config["namespace"]
+        app_name = config["name"]
+        pod_name = find_pod(namespace, app_name)
+
+        # Stream logs
+        stream_logs(pod_name, namespace)
+      end
+
+      private
+
+      def find_pod(namespace, app_name)
+        data = Kdep::Kubectl.run_json(
+          "get", "pods",
+          "-n", namespace,
+          "-l", "app=#{app_name}",
+          "--field-selector", "status.phase=Running"
+        )
+        pods = data["items"]
+
+        if pods.nil? || pods.empty?
+          @ui.error("No running pods found for #{app_name} in #{namespace}")
+          exit 1
+        end
+
+        pods[0]["metadata"]["name"]
+      end
+
+      def stream_logs(pod_name, namespace)
+        follow = @command_options.fetch(:follow, true)
+        tail = @command_options.fetch(:tail, 100)
+        container = @command_options[:container]
+
+        args = ["kubectl", "logs", pod_name, "-n", namespace]
+        args << "-f" if follow
+        args << "--tail=#{tail}"
+
+        if container
+          args << "-c"
+          args << container
+        end
+
+        io = IO.popen(args, "r")
+
+        Signal.trap("INT") { io.close rescue nil; exit 0 }
+
+        begin
+          io.each_line do |line|
+            puts highlight_line(line.chomp)
+          end
+        rescue Errno::EPIPE
+          # Clean exit on broken pipe
+        ensure
+          io.close rescue nil
+        end
+      end
+
+      def highlight_line(line)
+        color_enabled = @ui.instance_variable_get(:@color)
+        return line unless color_enabled
+
+        if line =~ /\b(ERROR|FATAL|PANIC)\b/
+          "\e[31m#{line}\e[0m"
+        elsif line =~ /\b(WARN|WARNING)\b/
+          "\e[33m#{line}\e[0m"
+        else
+          line
+        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/commands/push.rb

@@ -0,0 +1,94 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Push
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep push [deploy] [env]"
+          opts.separator ""
+          opts.separator "Pushes a built Docker image to the configured registry."
+          opts.separator ""
+        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
+
+        # Push
+        begin
+          Kdep::Docker.push(full_tag)
+          @ui.info("Pushed: #{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/render.rb

@@ -0,0 +1,130 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class Render
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep render [deploy] [env]"
+          opts.separator ""
+          opts.separator "Renders Kubernetes manifests for the specified deploy target and environment."
+        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
+
+        # Load preset resources
+        preset = Kdep::Preset.new(config["preset"], deploy_dir)
+        resources = preset.resources
+
+        # Determine output directory (.rendered/ in repo root)
+        repo_root = File.dirname(kdep_dir)
+        output_dir = File.join(repo_root, ".rendered")
+
+        # Set up writer and renderer
+        writer = Kdep::Writer.new(output_dir)
+        writer.clean
+        renderer = Kdep::Renderer.new(config, deploy_dir)
+        validator = Kdep::Validator.new
+
+        files_written = 0
+        errors = []
+
+        resources.each_with_index do |resource_name, idx|
+          index = idx + 1
+
+          # Render
+          begin
+            content = renderer.render_resource(resource_name)
+          rescue => e
+            errors << {"resource" => resource_name, "error" => e.message}
+            next
+          end
+
+          # Validate (skip empty content like ingress with no domains)
+          unless content.nil? || content.strip.empty?
+            result = validator.validate(content, resource_name)
+            unless result["valid"]
+              result["errors"].each do |err|
+                errors << {"resource" => resource_name, "error" => err}
+              end
+            end
+          end
+
+          # Write
+          path = writer.write(resource_name, content, index)
+          if path
+            relative_path = path.sub(repo_root + "/", "")
+            @ui.file_written(relative_path)
+            files_written += 1
+          end
+        end
+
+        # Print errors inline
+        errors.each do |err|
+          @ui.error("#{err["resource"]}: #{err["error"]}")
+        end
+
+        # Print summary
+        @ui.summary(files_written, errors.length)
+
+        exit 1 if errors.length > 0
+      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