kdep 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed01f5bcc6ebac09d59dd1d732d73e1913f29ce3f2a9efc7df67fbb914686973
-  data.tar.gz: 8b9191bdad263a0902c76a49ef1446e184ab7eae44a269c39947bff1387863fc
+  metadata.gz: f971ace54be5f10abde07364654600377be07f9f77c1b7afb5bb9f73e5b3ddfe
+  data.tar.gz: f2040905cec594653386a4a5f9049e6217628a29925d5f7fcc8aa0724eb873dc
 SHA512:
-  metadata.gz: 70b166608d549d46929c98a76b1930a5a23d42a0fbf71d118d649aecbbe7ca694524327b2cb3d58a1c19f1a1dc8bc28ac8a578740ffc3d55bc9cb0f17458c721
-  data.tar.gz: eedf3f6bfd98c1bd8820db578a5431abe919f11102575fa6dccbef6f3f2af84411968c797cae193974136749021502325ad270d3c0fdfc54b3c35086156403db
+  metadata.gz: 0cb2245173f84ca39286e957c7fce8a83491f403adc8c591c40da30cbe0f3ee26bf48ce432fa7c5deac669a43fdaa328212d3e1e00ec8266248164d76779957e
+  data.tar.gz: b4cbb931a8a08250b1489ad22e9020a4642650330b1efbf79329294f777f2f1cfeb85b9b02c97bd1a0901318efa0b6f2deaa3ee5791b05eaf7a4cf02339a4a69

data/lib/kdep/cli.rb

@@ -18,6 +18,7 @@ module Kdep
       "restart" => Commands::Restart,
       "scale"   => Commands::Scale,
       "migrate" => Commands::Migrate,
+      "helm-install" => Commands::HelmInstall,
       "dashboard" => Commands::Dashboard,
     }.freeze
 

data/lib/kdep/commands/apply.rb

@@ -55,7 +55,7 @@ module Kdep
         resources = preset.resources
 
         repo_root = File.dirname(kdep_dir)
-        output_dir = File.join(repo_root, ".rendered")
+        output_dir = File.join(deploy_dir, ".rendered")
 
         writer = Kdep::Writer.new(output_dir)
         writer.clean

data/lib/kdep/commands/bump.rb

@@ -63,14 +63,17 @@ module Kdep
         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 3: Read current tag from state.yml, increment minor
+          state_path = File.join(deploy_dir, "state.yml")
+          if File.exist?(state_path)
+            state = YAML.safe_load(File.read(state_path)) || {}
+            current_tag = state["tag"] || "0.0"
+          else
+            current_tag = "0.0"
+          end
+          parsed = Kdep::VersionTagger.parse(current_tag)
+          next_version = parsed ? "#{parsed[0]}.#{parsed[1] + 1}" : "0.1"
+          @ui.info("#{current_tag} -> #{next_version}")
 
           # Step 5: Build
           if registry_url && !registry_url.to_s.empty?
@@ -84,7 +87,8 @@ module Kdep
             context_dir: repo_root,
             dockerfile: config["dockerfile"],
             target: config["target"],
-            platform: @command_options[:platform] || config["platform"]
+            platform: @command_options[:platform] || config["platform"],
+            build_args: config["build_args"]
           )
           @ui.info("Built: #{full_tag}")
 
@@ -99,7 +103,7 @@ module Kdep
             # Render manifests
             preset = Kdep::Preset.new(config["preset"], deploy_dir)
             resources = preset.resources
-            output_dir = File.join(repo_root, ".rendered")
+            output_dir = File.join(deploy_dir, ".rendered")
 
             writer = Kdep::Writer.new(output_dir)
             writer.clean
@@ -161,6 +165,9 @@ module Kdep
               if errors.empty?
                 @ui.info("#{applied} files applied, 0 errors")
 
+                # Save new tag to state.yml
+                File.write(File.join(deploy_dir, "state.yml"), YAML.dump({"tag" => next_version}))
+
                 # Launch TUI dashboard for live monitoring
                 unless @command_options[:"no-dashboard"]
                   dashboard = Kdep::Dashboard.new(

data/lib/kdep/commands/diff.rb

@@ -53,7 +53,7 @@ module Kdep
         resources = preset.resources
 
         repo_root = File.dirname(kdep_dir)
-        output_dir = File.join(repo_root, ".rendered")
+        output_dir = File.join(deploy_dir, ".rendered")
 
         writer = Kdep::Writer.new(output_dir)
         writer.clean

data/lib/kdep/commands/helm_install.rb

@@ -0,0 +1,286 @@
+require "optparse"
+
+module Kdep
+  module Commands
+    class HelmInstall
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep helm-install [deploy] [env]"
+          opts.separator ""
+          opts.separator "Runs helm upgrade --install for a helm preset deploy target,"
+          opts.separator "then renders and applies any additional k8s resources (ingress, secrets)."
+          opts.separator ""
+          opts.separator "Supports single chart (chart:) or multiple charts (charts: array)."
+          opts.separator ""
+          opts.on("--dry-run", "Show what would be run without executing")
+        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]
+        @dry_run = @command_options[:"dry-run"]
+
+        # 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
+        @namespace = config["namespace"]
+
+        unless config["preset"] == "helm"
+          @ui.error("#{deploy_name} is not a helm preset (preset: #{config["preset"]})")
+          exit 1
+        end
+
+        # Validate context
+        begin
+          Kdep::ContextGuard.new(config["context"]).validate!
+        rescue Kdep::Kubectl::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+
+        # Load secrets for --set interpolation
+        @secrets = load_secrets(@deploy_dir)
+
+        # Add helm repos
+        repos = config["helm_repos"] || {}
+        # Also support singular helm_repo for backward compat
+        if config["helm_repo"]
+          repo_name, repo_url = config["helm_repo"].split("=", 2)
+          repos[repo_name] = repo_url if repo_name && repo_url
+        end
+
+        repos.each do |repo_name, repo_url|
+          @ui.info("Adding helm repo: #{repo_name} -> #{repo_url}")
+          Kdep::Helm.repo_add(repo_name, repo_url) unless @dry_run
+        end
+
+        # Install charts
+        charts = build_chart_list(config)
+
+        if charts.empty?
+          @ui.error("app.yml has no chart or charts defined")
+          exit 1
+        end
+
+        charts.each do |chart_conf|
+          install_chart(chart_conf)
+        end
+
+        # Render and apply additional k8s resources (ingress, secret, etc.)
+        apply_extra_resources(config, kdep_dir)
+      end
+
+      private
+
+      # Build a normalized list of chart configs.
+      # Supports:
+      #   chart: livekit/livekit-server         (single)
+      #   charts:                                (multiple)
+      #     - release: livekit-server
+      #       chart: livekit/livekit-server
+      #       values: server-values.yaml
+      #       sets: { ... }
+      def build_chart_list(config)
+        if config["charts"]
+          config["charts"].map do |c|
+            {
+              release: c["release"] || config["name"],
+              chart: c["chart"],
+              values: c["values"],
+              sets: c["sets"] || {},
+            }
+          end
+        elsif config["chart"]
+          [{
+            release: config["release"] || config["name"],
+            chart: config["chart"],
+            values: nil, # auto-detect values.yml in deploy dir
+            sets: config["helm_sets"] || {},
+          }]
+        else
+          []
+        end
+      end
+
+      def install_chart(chart_conf)
+        release = chart_conf[:release]
+        chart = chart_conf[:chart]
+
+        # Resolve values file
+        values_file = resolve_values_file(chart_conf[:values])
+
+        # Build --set arguments, interpolating secrets
+        sets = {}
+        chart_conf[:sets].each do |key, value|
+          sets[key] = interpolate(value.to_s, @secrets)
+        end
+
+        @ui.info("helm upgrade --install #{release} #{chart} -n #{@namespace}")
+        @ui.info("  values: #{values_file}") if values_file
+        sets.each { |k, v| @ui.info("  --set #{k}=#{mask(v)}") }
+
+        begin
+          output = Kdep::Helm.upgrade_install(
+            release: release,
+            chart: chart,
+            namespace: @namespace,
+            values_file: values_file,
+            sets: sets,
+            dry_run: @dry_run
+          )
+          @ui.info(output) unless output.strip.empty?
+          @ui.success("helm install complete: #{release}")
+        rescue Kdep::Helm::Error => e
+          @ui.error(e.message)
+          exit 1
+        end
+      end
+
+      def resolve_values_file(explicit_name)
+        if explicit_name
+          path = File.join(@deploy_dir, explicit_name)
+          return path if File.exist?(path)
+          @ui.warn("Values file not found: #{explicit_name}")
+          return nil
+        end
+
+        # Auto-detect values.yml or values.yaml
+        %w[values.yml values.yaml].each do |name|
+          path = File.join(@deploy_dir, name)
+          return path if File.exist?(path)
+        end
+        nil
+      end
+
+      def apply_extra_resources(config, kdep_dir)
+        preset = Kdep::Preset.new("helm", @deploy_dir)
+        resources = preset.resources
+        return if resources.empty?
+
+        repo_root = File.dirname(kdep_dir)
+        output_dir = File.join(@deploy_dir, ".rendered")
+
+        writer = Kdep::Writer.new(output_dir)
+        writer.clean
+        renderer = Kdep::Renderer.new(config, @deploy_dir)
+        validator = Kdep::Validator.new
+
+        files_written = 0
+        render_errors = []
+
+        resources.each_with_index do |resource_name, idx|
+          index = idx + 1
+          begin
+            content = renderer.render_resource(resource_name)
+          rescue => e
+            render_errors << "#{resource_name}: #{e.message}"
+            next
+          end
+
+          unless content.nil? || content.strip.empty?
+            result = validator.validate(content, resource_name)
+            unless result["valid"]
+              result["errors"].each do |err|
+                render_errors << "#{resource_name}: #{err}"
+              end
+            end
+          end
+
+          path = writer.write(resource_name, content, index)
+          if path
+            @ui.file_written(path.sub(repo_root + "/", ""))
+            files_written += 1
+          end
+        end
+
+        render_errors.each { |err| @ui.error(err) } unless render_errors.empty?
+
+        unless @dry_run
+          rendered_files = Dir.glob(File.join(output_dir, "*.yml")).sort
+          applied = 0
+          apply_errors = []
+
+          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
+              apply_errors << e.message
+              @ui.error("#{File.basename(file_path)}: #{e.message}")
+            end
+          end
+
+          @ui.info("#{applied} additional resources applied") if applied > 0
+          exit 1 if apply_errors.any?
+        end
+      end
+
+      def interpolate(value, secrets)
+        value.gsub(/\$\{(\w+)\}/) do
+          key = $1
+          secrets[key] || ENV[key] || "${#{key}}"
+        end
+      end
+
+      def mask(value)
+        return value if value.length <= 8
+        value[0..3] + "****"
+      end
+
+      def load_secrets(deploy_dir)
+        secrets_path = File.join(deploy_dir, "secrets.yml")
+        return {} unless File.exist?(secrets_path)
+
+        content = File.read(secrets_path)
+        YAML.safe_load(content) || {}
+      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
+            @ui.info("Available deploys: #{deploys.join(', ')}") if deploys.any?
+            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