kdep 0.1.3 → 0.2.0

data/lib/kdep/commands/migrate.rb

@@ -1,6 +1,7 @@
 require "optparse"
 require "fileutils"
 require "yaml"
+require "tmpdir"
 
 module Kdep
   module Commands
@@ -9,8 +10,9 @@ module Kdep
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep migrate [path]"
           opts.separator ""
-          opts.separator "Converts old deploy files (.app-name + app.yml) to kdep format."
-          opts.separator "Verifies byte-for-byte match between old materialized and new rendered output."
+          opts.separator "Converts old deploy directories to kdep format."
+          opts.separator "Supports both old pattern (.app-name + deploy/) and"
+          opts.separator "new pattern (deploy_web/app.yml + subdirectories)."
         end
       end
 
@@ -37,8 +39,8 @@ module Kdep
         # Parse old format
         old = Kdep::OldFormat.new(path)
         begin
-          name = old.app_name
           kdep_config = old.to_kdep_config
+          name = kdep_config["name"] || old.app_name
         rescue => e
           @ui.error(e.message)
           exit 1
@@ -55,102 +57,205 @@ module Kdep
         File.write(File.join(target_dir, "app.yml"), YAML.dump(kdep_config))
         @ui.file_written("kdep/#{name}/app.yml")
 
-        # Warn about secrets
-        @ui.warn("Secrets must be manually migrated to kdep/#{name}/secrets.yml")
+        # Extract and write env vars from ConfigMap
+        env = old.extract_env
+        unless env.empty?
+          @ui.info("Extracted #{env.size} env vars from ConfigMap (already in envFrom refs)")
+        end
 
-        # Render via existing pipeline
-        config = Kdep::Config.new(target_dir).load
-        preset = Kdep::Preset.new(config["preset"], target_dir)
-        resources = preset.resources
+        # Extract and write secrets (decode base64 =>plain text for secrets.yml)
+        secrets = old.extract_secrets
+        if secrets.empty?
+          @ui.warn("No secrets found. Create kdep/#{name}/secrets.yml manually if needed.")
+        else
+          require "base64"
+          decoded = {}
+          secrets.each do |k, v|
+            decoded[k] = Base64.decode64(v) rescue v
+          end
+          secrets_path = File.join(target_dir, "secrets.yml")
+          File.write(secrets_path, YAML.dump(decoded))
+          @ui.file_written("kdep/#{name}/secrets.yml")
+          @ui.warn("#{secrets.size} secrets written. Review kdep/#{name}/secrets.yml — values are now plain text.")
+        end
 
-        output_dir = File.join(Dir.pwd, ".rendered")
-        writer = Kdep::Writer.new(output_dir)
-        writer.clean
-        renderer = Kdep::Renderer.new(config, target_dir)
+        # Generate custom resource templates (PVC, stringData Secrets)
+        custom_resources = old.extract_custom_resources
+        unless custom_resources.empty?
+          res_dir = File.join(target_dir, "resources")
+          FileUtils.mkdir_p(res_dir)
+          custom_resources.each do |cr|
+            kind = cr["kind"]
+            doc = cr["doc"]
+            res_name = doc.dig("metadata", "name") || kind.downcase
+            filename = "#{res_name.gsub(/[^a-zA-Z0-9_-]/, "-")}.yml.erb"
+            File.write(File.join(res_dir, filename), YAML.dump(doc))
+            @ui.file_written("kdep/#{name}/resources/#{filename}")
+          end
+          @ui.info("#{custom_resources.size} custom resource(s) generated as templates")
+        end
 
-        rendered_files = []
-        resources.each_with_index do |resource_name, idx|
-          content = renderer.render_resource(resource_name)
-          written_path = writer.write(resource_name, content, idx + 1)
-          rendered_files << written_path if written_path
+        @ui.success("Migration complete: kdep/#{name}/")
+        @ui.info("")
+        @ui.info("Generated config:")
+        kdep_config.each do |k, v|
+          if v.is_a?(Hash) || v.is_a?(Array)
+            @ui.info("  #{k}: #{v.inspect}")
+          else
+            @ui.info("  #{k}: #{v}")
+          end
         end
 
-        # Compare byte-for-byte against old materialized files
+        # Automatic post-migration verification
+        @ui.info("")
+        verify_migration(old, target_dir, kdep_config)
+
+        @ui.info("")
+        @ui.info("Next: review kdep/#{name}/app.yml, then `kdep render #{name}` to test")
+      end
+
+      private
+
+      def verify_migration(old, target_dir, kdep_config)
+        @ui.info("Verifying migration...")
+
         old_files = old.materialized_files
         if old_files.empty?
-          @ui.warn("No materialized files found to verify against")
-          @ui.success("Migration complete: kdep/#{name}/")
+          @ui.warn("No old manifests found to verify against")
           return
         end
 
-        mismatches = compare_files(old_files, rendered_files)
+        old_by_kind = parse_yamls(old_files)
 
-        if mismatches.empty?
-          @ui.success("Migration verified: #{rendered_files.length} files match byte-for-byte")
-          @ui.success("Migration complete: kdep/#{name}/")
-        else
-          @ui.error("Migration verification failed: #{mismatches.length} file(s) differ")
-          mismatches.each do |m|
-            @ui.error("  #{m[:file]}:")
-            m[:diff].each { |line| @ui.info("    #{line}") }
+        # Render new manifests to a temp dir
+        config = Kdep::Config.new(target_dir).load
+        preset = Kdep::Preset.new(config["preset"], target_dir)
+
+        Dir.mktmpdir("kdep-verify") do |tmpdir|
+          output_dir = File.join(tmpdir, ".rendered")
+          writer = Kdep::Writer.new(output_dir)
+          writer.clean
+          renderer = Kdep::Renderer.new(config, target_dir)
+
+          rendered_files = []
+          preset.resources.each_with_index do |res, idx|
+            content = renderer.render_resource(res)
+            path = writer.write(res, content, idx + 1)
+            rendered_files << path if path
           end
-          # Clean up failed migration
-          FileUtils.rm_rf(target_dir)
-          @ui.error("Migration aborted. Generated config removed.")
-          exit 1
-        end
-      end
 
-      private
+          new_by_kind = parse_yamls(rendered_files)
 
-      def compare_files(old_files, new_files)
-        mismatches = []
-        # Match by filename (basename)
-        old_by_name = {}
-        old_files.each { |f| old_by_name[File.basename(f)] = f }
+          diffs = collect_diffs(old_by_kind, new_by_kind)
 
-        new_by_name = {}
-        new_files.each { |f| new_by_name[File.basename(f)] = f }
+          if diffs.empty?
+            @ui.success("Verification passed: all fields match")
+          else
+            field_count = diffs.count { |d| d.include?("  ~ ") || d.include?("  + ") || d.include?("  - ") }
+            @ui.info("")
+            @ui.info(colorize(:bold, "Verification diff (#{field_count} field diffs, old => new):"))
+            diffs.each { |d| puts d }
+          end
+        end
+      rescue => e
+        @ui.warn("Verification failed: #{e.message}")
+      end
 
-        # Check all old files have matching new files
-        old_by_name.each do |name, old_path|
-          new_path = new_by_name[name]
-          unless new_path
-            mismatches << { file: name, diff: ["- File exists in old but not in new rendered output"] }
+      def collect_diffs(old_by_kind, new_by_kind)
+        diffs = []
+        old_by_kind.each do |kind, old_entry|
+          new_entry = new_by_kind[kind]
+          unless new_entry
+            diffs << colorize(:red, "  #{kind}: MISSING in rendered")
             next
           end
+          kind_diffs = tree_diff(old_entry["doc"], new_entry["doc"])
+          unless kind_diffs.empty?
+            diffs << colorize(:bold, "  #{kind}:")
+            diffs.concat(kind_diffs)
+          end
+        end
+        new_by_kind.each do |kind, _|
+          unless old_by_kind.keys.any? { |k| k.start_with?(kind) }
+            diffs << colorize(:yellow, "  #{kind}: EXTRA in rendered")
+          end
+        end
+        diffs
+      end
 
-          old_content = File.read(old_path)
-          new_content = File.read(new_path)
+      def tree_diff(old_val, new_val, path = "")
+        old_val = normalize(old_val)
+        new_val = normalize(new_val)
+        diffs = []
 
-          if old_content != new_content
-            mismatches << { file: name, diff: generate_diff(old_content, new_content) }
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          (old_val.keys + new_val.keys).uniq.sort.each do |k|
+            p = path.empty? ? k.to_s : "#{path}.#{k}"
+            if !old_val.key?(k)
+              diffs << colorize(:green, "  + #{p}: #{fmt(new_val[k])}")
+            elsif !new_val.key?(k)
+              diffs << colorize(:red, "  - #{p}: #{fmt(old_val[k])}")
+            else
+              diffs.concat(tree_diff(old_val[k], new_val[k], p))
+            end
+          end
+        elsif old_val.is_a?(Array) && new_val.is_a?(Array)
+          [old_val.size, new_val.size].max.times do |i|
+            p = "#{path}[#{i}]"
+            if i >= old_val.size
+              diffs << colorize(:green, "  + #{p}: #{fmt(new_val[i])}")
+            elsif i >= new_val.size
+              diffs << colorize(:red, "  - #{p}: #{fmt(old_val[i])}")
+            else
+              diffs.concat(tree_diff(old_val[i], new_val[i], p))
+            end
           end
+        elsif old_val != new_val
+          diffs << colorize(:yellow, "  ~ #{p || path}: #{fmt(old_val)} => #{fmt(new_val)}")
         end
+        diffs
+      end
 
-        # Check for new files not in old
-        new_by_name.each do |name, _|
-          unless old_by_name.key?(name)
-            mismatches << { file: name, diff: ["+ File exists in new but not in old materialized output"] }
-          end
+      def normalize(obj)
+        case obj
+        when Hash
+          obj.sort_by { |k, _| k.to_s }.map { |k, v| [k, normalize(v)] }.to_h
+        when Array
+          obj.map { |v| normalize(v) }
+        when String
+          # Normalize image tags — tags are managed by kdep bump
+          obj.match?(/:\d+[\.\d]*\z/) ? obj.sub(/:[^:]+\z/, ":TAG") : obj
+        else
+          obj
         end
+      end
 
-        mismatches
+      def fmt(val)
+        case val
+        when Hash, Array then val.inspect[0, 80]
+        else val.inspect
+        end
       end
 
-      def generate_diff(old_content, new_content)
-        old_lines = old_content.lines.map(&:chomp)
-        new_lines = new_content.lines.map(&:chomp)
-        diffs = []
-        max = [old_lines.length, new_lines.length].max
-        max.times do |i|
-          old_line = old_lines[i]
-          new_line = new_lines[i]
-          next if old_line == new_line
-          diffs << "- #{old_line}" if old_line
-          diffs << "+ #{new_line}" if new_line
+      def parse_yamls(files)
+        by_kind = {}
+        files.each do |f|
+          File.read(f).split(/^---\s*$/).each do |part|
+            next if part.strip.empty?
+            doc = YAML.safe_load(part) rescue next
+            next unless doc.is_a?(Hash) && doc["kind"]
+            kind = doc["kind"]
+            kind = "#{kind}_#{by_kind.keys.count { |k| k.start_with?(doc["kind"]) }}" if by_kind[kind]
+            by_kind[kind] = { "doc" => doc, "file" => f }
+          end
         end
-        diffs
+        by_kind
+      end
+
+      def colorize(color, text)
+        return text unless $stdout.tty?
+        colors = { red: "\e[31m", green: "\e[32m", yellow: "\e[33m", bold: "\e[1m" }
+        "#{colors[color]}#{text}\e[0m"
       end
     end
   end

data/lib/kdep/commands/render.rb

@@ -44,9 +44,9 @@ module Kdep
         preset = Kdep::Preset.new(config["preset"], deploy_dir)
         resources = preset.resources
 
-        # Determine output directory (.rendered/ in repo root)
+        # Determine output directory (.rendered/ in deploy target dir)
         repo_root = File.dirname(kdep_dir)
-        output_dir = File.join(repo_root, ".rendered")
+        output_dir = File.join(deploy_dir, ".rendered")
 
         # Set up writer and renderer
         writer = Kdep::Writer.new(output_dir)

data/lib/kdep/defaults.rb

@@ -1,15 +1,19 @@
 module Kdep
   module Defaults
     BASE_DEFAULTS = {
-      "port" => 8080,
       "replicas" => 1,
+      "namespace" => "default",
+      "platform" => "linux/amd64",
     }.freeze
 
     PRESET_OVERRIDES = {
-      "web"     => { "replicas" => 3 },
+      "web"     => { "replicas" => 3, "port" => 8080 },
       "worker"  => {},
       "job"     => {},
       "cronjob" => {},
+      "statefulset" => {},
+      "statefulset_svc" => {},
+      "helm"    => {},
       "custom"  => {},
     }.freeze
 

data/lib/kdep/docker.rb

@@ -4,11 +4,16 @@ module Kdep
   module Docker
     class Error < StandardError; end
 
-    def self.build(tag:, context_dir:, dockerfile: nil, target: nil, platform: nil)
+    def self.build(tag:, context_dir:, dockerfile: nil, target: nil, platform: nil, build_args: nil)
+      ensure_login(tag)
+
       args = ["docker", "build", "-t", tag]
       args.push("--file", dockerfile) if dockerfile
       args.push("--target", target) if target
       args.push("--platform", platform) if platform
+      if build_args.is_a?(Hash)
+        build_args.each { |k, v| args.push("--build-arg", "#{k}=#{v}") }
+      end
       args.push(context_dir)
 
       stdout, stderr, status = Open3.capture3(*args)
@@ -19,11 +24,62 @@ module Kdep
     end
 
     def self.push(tag)
+      ensure_login(tag)
+
       stdout, stderr, status = Open3.capture3("docker", "push", tag)
       unless status.success?
         raise Error, "docker push failed: #{stderr.strip}"
       end
       stdout
     end
+
+    def self.ensure_login(tag)
+      server = tag.split("/").first
+      return unless server && server.include?(".")
+
+      @logged_in ||= {}
+      return if @logged_in[server]
+
+      user, pass = read_credentials(server)
+      return unless user && pass
+
+      _, stderr, status = Open3.capture3(
+        "docker", "login", server, "-u", user, "--password-stdin",
+        stdin_data: pass
+      )
+      if status.success?
+        @logged_in[server] = true
+      else
+        $stderr.puts "warning: docker login to #{server} failed: #{stderr.strip}"
+      end
+    end
+
+    def self.read_credentials(server)
+      # Try ~/.leadfycr (default for leadfycr.azurecr.io)
+      cred_file = File.join(Dir.home, ".leadfycr")
+      if File.exist?(cred_file)
+        parts = File.read(cred_file).strip.split(":", 2)
+        return parts if parts.length == 2
+      end
+
+      # Try ~/.docker/config.json
+      config_path = File.join(Dir.home, ".docker", "config.json")
+      if File.exist?(config_path)
+        begin
+          config = JSON.parse(File.read(config_path))
+          entry = (config["auths"] || {})[server]
+          if entry && entry["auth"]
+            decoded = Base64.decode64(entry["auth"])
+            parts = decoded.split(":", 2)
+            return parts if parts.length == 2
+          end
+        rescue StandardError
+        end
+      end
+
+      [nil, nil]
+    end
+
+    private_class_method :ensure_login, :read_credentials
   end
 end

data/lib/kdep/helm.rb

@@ -0,0 +1,34 @@
+require "open3"
+
+module Kdep
+  module Helm
+    class Error < StandardError; end
+
+    def self.run(*args)
+      stdout, stderr, status = Open3.capture3("helm", *args)
+      unless status.success?
+        raise Error, "helm #{args.first} failed: #{stderr.strip}"
+      end
+      stdout
+    end
+
+    # helm upgrade --install <release> <chart> -n <namespace> [-f values.yml] [--set k=v ...]
+    def self.upgrade_install(release:, chart:, namespace:, values_file: nil, sets: {}, dry_run: false)
+      args = ["upgrade", "--install", release, chart, "-n", namespace]
+      args += ["-f", values_file] if values_file
+      sets.each do |key, value|
+        args += ["--set", "#{key}=#{value}"]
+      end
+      args << "--dry-run" if dry_run
+      run(*args)
+    end
+
+    def self.repo_add(name, url)
+      run("repo", "add", name, url, "--force-update")
+    end
+
+    def self.repo_update
+      run("repo", "update")
+    end
+  end
+end