kdep 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95e9b9f35fb62ccb1d6e7e3c375e0a68e629b7bc81f7959c57d14eb33af19e5d
-  data.tar.gz: 5f5e8d59539c690e57d110fd109ea4c38d34081747f62f08e60b9397991faae4
+  metadata.gz: 2f2546356a99516a639dc29b0d25a6494898c351a2dd40ca58a3510da93aa49d
+  data.tar.gz: ea992fe366d4d6875b1edf6d976d2c8ece688854d76dfd12ab87031c85ffda6d
 SHA512:
-  metadata.gz: 7a208e0fdc9c932ddb5a1c68cc5d15401e95fd18fb598293045cb0beeef43c74d38a3300224f961d30dba477702279af0caa0e86116beafa8ea14d678783adb3
-  data.tar.gz: 3046797ac1769ac6c238a1fd8de10be4fac0bab2492557bb0a27447470d5cac6edf222779dd59195d9be0d1253935fbdffbb3e728e97ea3352e08883c3cef5a6
+  metadata.gz: 122d63cdabc4fda2ff9f7f52f546dc5288d26209ec9f7025ee93cbdd0109e4de094e37af1b5073266b6b5a5d939ca15fcd65004dc79c5eda286709bc4fb059d3
+  data.tar.gz: 2aee7b30512d9102f86bf1150b6ee5054f741497bc4009784dbaf38f2d2f222ae6b8c3a2249090c3a9dad5a31fcdf013c8c753e7f07dd761051ccc189e0450f8

data/lib/kdep/cli.rb

@@ -20,6 +20,7 @@ module Kdep
       "migrate" => Commands::Migrate,
       "helm-install" => Commands::HelmInstall,
       "dashboard" => Commands::Dashboard,
+      "doctor" => Commands::Doctor,
     }.freeze
 
     def initialize(argv)

data/lib/kdep/commands/bump.rb

@@ -13,6 +13,7 @@ module Kdep
           opts.on("--dry-run", "Run full pipeline but skip kubectl apply")
           opts.on("--no-dashboard", "Skip TUI dashboard after deploy")
           opts.on("--platform=PLATFORM", "Target platform (e.g., linux/amd64)")
+          opts.on("--init-state", "Seed state.yml at 0.0 when missing (non-interactive)")
         end
       end
 
@@ -64,12 +65,18 @@ module Kdep
 
         begin
           # 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"
+          begin
+            current_tag = Kdep::State.tag(deploy_dir) || handle_missing_state(deploy_dir)
+          rescue Kdep::State::Error => e
+            @ui.error(e.message)
+            exit 1
+          end
+          # to_fix.md #3 — warn if someone has gitignored state.yml
+          require "kdep/doctor/check_state_gitignored"
+          gitignore_result = Kdep::Doctor::CheckStateGitignored.new(deploy_dir).run
+          if gitignore_result.severity == :error
+            @ui.warn(gitignore_result.message)
+            @ui.warn(gitignore_result.hint) if gitignore_result.hint
           end
           parsed = Kdep::VersionTagger.parse(current_tag)
           next_version = parsed ? "#{parsed[0]}.#{parsed[1] + 1}" : "0.1"
@@ -113,12 +120,7 @@ module Kdep
 
             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
+              content = renderer.render_resource(resource_name)
 
               unless content.nil? || content.strip.empty?
                 result = validator.validate(content, resource_name)
@@ -148,7 +150,6 @@ module Kdep
             else
               # Apply
               namespace = config["namespace"]
-              errors = []
               applied = 0
 
               rendered_files.each do |file_path|
@@ -157,30 +158,25 @@ module Kdep
                   @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}")
+                  exit 1
                 end
               end
 
-              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(
-                    "name" => config["name"],
-                    "namespace" => namespace,
-                    "registry" => config["registry"],
-                    "image" => image
-                  )
-                  dashboard.run
-                end
-              else
-                @ui.info("#{applied} files applied, #{errors.length} errors")
-                exit 1
+              @ui.info("#{applied} files applied, 0 errors")
+
+              # Save new tag to state.yml
+              Kdep::State.write(deploy_dir, tag: next_version)
+
+              # Launch TUI dashboard for live monitoring
+              unless @command_options[:"no-dashboard"]
+                dashboard = Kdep::Dashboard.new(
+                  "name" => config["name"],
+                  "namespace" => namespace,
+                  "registry" => config["registry"],
+                  "image" => image
+                )
+                dashboard.run
               end
             end
           end
@@ -196,6 +192,41 @@ module Kdep
 
       private
 
+      def handle_missing_state(deploy_dir)
+        if @command_options[:"init-state"]
+          seed_initial_state(deploy_dir, reason: :flag)
+        elsif $stdin.tty?
+          prompt_for_init(deploy_dir)
+        else
+          @ui.error(
+            "state.yml not found in #{deploy_dir}.\n" \
+            "Re-run with --init-state to seed at \"#{Kdep::State::INITIAL_TAG}\" " \
+            "(first deploy will be tag \"0.1\"), or commit a state.yml manually."
+          )
+          exit 1
+        end
+      end
+
+      def prompt_for_init(deploy_dir)
+        @ui.warn("No state.yml found in #{deploy_dir}.")
+        @ui.warn("If prod is already running a higher tag, this will regress it.")
+        print %Q(Seed state.yml at "#{Kdep::State::INITIAL_TAG}" and proceed? [y/N] )
+        answer = $stdin.gets&.strip&.downcase
+        unless %w[y yes].include?(answer)
+          @ui.info("Aborted.")
+          exit 0
+        end
+        seed_initial_state(deploy_dir, reason: :prompt)
+      end
+
+      def seed_initial_state(deploy_dir, reason:)
+        tag = Kdep::State::INITIAL_TAG
+        Kdep::State.write(deploy_dir, tag: tag)
+        source = reason == :flag ? "--init-state flag" : "user confirmation"
+        @ui.info("Seeded state.yml at #{tag} (#{source}). First deploy will be tag 0.1.")
+        tag
+      end
+
       def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
         if deploy_name
           deploy_dir = File.join(kdep_dir, deploy_name)

data/lib/kdep/commands/diff.rb

@@ -48,37 +48,43 @@ module Kdep
           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(deploy_dir, ".rendered")
-
-        writer = Kdep::Writer.new(output_dir)
-        writer.clean
-        renderer = Kdep::Renderer.new(config, deploy_dir)
+        # Inject tag from state.yml if present (to_fix.md #1)
+        if (state_tag = Kdep::State.tag(deploy_dir))
+          config["tag"] = state_tag
+        else
+          @ui.warn("No state.yml in #{deploy_dir} -- diff will compare preset default tag against live cluster.")
+        end
 
-        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
+        # Render into a temp dir so we never clobber .rendered/ (owned by bump/render)
+        require "tmpdir"
+        Dir.mktmpdir("kdep-diff-") do |tmpdir|
+          preset = Kdep::Preset.new(config["preset"], deploy_dir)
+          writer = Kdep::Writer.new(tmpdir)
+          renderer = Kdep::Renderer.new(config, deploy_dir)
+
+          preset.resources.each_with_index do |resource_name, idx|
+            begin
+              content = renderer.render_resource(resource_name)
+            rescue => e
+              @ui.error("#{resource_name}: #{e.message}")
+              next
+            end
+            writer.write(resource_name, content, idx + 1)
           end
-          writer.write(resource_name, content, index)
+
+          rendered_files = Dir.glob(File.join(tmpdir, "*.yml")).sort
+          run_diff(rendered_files)
         end
+      end
 
-        # Get sorted rendered files
-        rendered_files = Dir.glob(File.join(output_dir, "*.yml")).sort
+      private
 
+      def run_diff(rendered_files)
         if rendered_files.empty?
           @ui.info("No rendered files to diff")
           return
         end
 
-        # Diff each file against live cluster state
         has_diffs = false
         errors = []
 
@@ -101,8 +107,6 @@ module Kdep
         end
       end
 
-      private
-
       def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
         if deploy_name
           deploy_dir = File.join(kdep_dir, deploy_name)

data/lib/kdep/commands/doctor.rb

@@ -0,0 +1,99 @@
+require "optparse"
+require "json"
+require "fileutils"
+
+module Kdep
+  module Commands
+    class Doctor
+      def self.option_parser
+        OptionParser.new do |opts|
+          opts.banner = "Usage: kdep doctor [deploy]"
+          opts.separator ""
+          opts.separator "Runs health checks against the kdep/ directory."
+          opts.separator "With a deploy name, checks only that deploy; otherwise, checks all."
+          opts.separator ""
+          opts.on("--fix", "Auto-fix safe issues (missing .gitignore only)")
+          opts.on("--only=CHECKS", "Comma-separated check IDs to run")
+          opts.on("--format=FORMAT", "Output format: text (default) or json")
+        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]
+        discovery = Kdep::Discovery.new
+        kdep_dir = discovery.find_kdep_dir
+
+        unless kdep_dir
+          @ui.error("No kdep/ directory found")
+          exit 1
+        end
+
+        deploys = deploy_name ? [deploy_name] : discovery.find_deploys
+        only = (@command_options[:only] || "").split(",").map(&:strip).reject(&:empty?)
+        format = @command_options[:format] || "text"
+
+        all_results = []
+        deploys.each do |name|
+          deploy_dir = File.join(kdep_dir, name)
+          unless File.directory?(deploy_dir)
+            @ui.error("Deploy not found: #{name}")
+            exit 1
+          end
+          Kdep::Doctor::CHECKS.each do |check_class|
+            id = check_class.const_get(:ID)
+            next if !only.empty? && !only.include?(id)
+            result = check_class.new(deploy_dir).run
+            all_results << { deploy: name, result: result }
+            apply_fix(check_class, deploy_dir, result) if @command_options[:fix]
+          end
+        end
+
+        if format == "json"
+          puts JSON.pretty_generate(all_results.map { |r| r[:result].to_h.merge(deploy: r[:deploy]) })
+        else
+          render_text(all_results)
+        end
+
+        exit 1 if all_results.any? { |r| r[:result].severity == :error }
+      end
+
+      private
+
+      def render_text(entries)
+        entries.each do |entry|
+          r = entry[:result]
+          prefix = case r.severity
+                   when :ok    then "OK   "
+                   when :info  then "INFO "
+                   when :warn  then "WARN "
+                   when :error then "ERR  "
+                   else r.severity.to_s.upcase.ljust(5)
+                   end
+          line = "#{prefix} [#{entry[:deploy]}] #{r.id}"
+          line += ": #{r.message}" if r.message
+          puts line
+          puts "      -> #{r.hint}" if r.hint
+        end
+      end
+
+      def apply_fix(check_class, deploy_dir, result)
+        return unless result.severity != :ok
+        return unless check_class == Kdep::Doctor::CheckGitignoreCanonical
+        path = File.join(deploy_dir, ".gitignore")
+        return if File.exist?(path)
+        FileUtils.cp(
+          File.join(Kdep.templates_dir, "init", "gitignore"),
+          path
+        )
+        @ui.file_written(path)
+      end
+    end
+  end
+end

data/lib/kdep/commands/migrate.rb

@@ -57,6 +57,28 @@ module Kdep
         File.write(File.join(target_dir, "app.yml"), YAML.dump(kdep_config))
         @ui.file_written("kdep/#{name}/app.yml")
 
+        # Copy canonical .gitignore so the migrated deploy stops
+        # at the same ignores as 'kdep init' uses (no state.yml!).
+        FileUtils.cp(
+          File.join(Kdep.templates_dir, "init", "gitignore"),
+          File.join(target_dir, ".gitignore")
+        )
+        @ui.file_written("kdep/#{name}/.gitignore")
+
+        # Seed state.yml from the live deploy's image tag so the
+        # first 'kdep bump' post-migration produces the NEXT tag,
+        # not 0.1 (which would regress prod).
+        if (tag = old.extracted_tag)
+          Kdep::State.write(target_dir, tag: tag)
+          @ui.file_written("kdep/#{name}/state.yml")
+          @ui.info("Seeded state.yml from live deploy tag: #{tag}")
+          unless Kdep::State.parseable_tag?(tag)
+            @ui.warn("Tag #{tag} is not kdep's major.minor format. Verify state.yml before bumping; next bump may produce 0.1.")
+          end
+        else
+          @ui.warn("Could not extract tag from old deploy (latest/missing). Next 'kdep bump' will prompt to seed state.")
+        end
+
         # Extract and write env vars from ConfigMap
         env = old.extract_env
         unless env.empty?

data/lib/kdep/commands/render.rb

@@ -40,6 +40,12 @@ module Kdep
         # Load config
         config = Kdep::Config.new(deploy_dir, env).load
 
+        if (state_tag = Kdep::State.tag(deploy_dir))
+          config["tag"] = state_tag
+        else
+          @ui.warn("No state.yml in #{deploy_dir} -- rendering with preset default tag. Run 'kdep bump' to establish state.")
+        end
+
         # Load preset resources
         preset = Kdep::Preset.new(config["preset"], deploy_dir)
         resources = preset.resources

data/lib/kdep/docker.rb

@@ -48,19 +48,31 @@ module Kdep
         "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}"
+      unless status.success?
+        raise Error, "docker login to #{server} failed: #{stderr.strip}"
       end
+      @logged_in[server] = true
     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
+      # Try ~/.github-pat + ~/.github-user (for ghcr.io)
+      if server == "ghcr.io" || server.end_with?(".ghcr.io")
+        pat_file = File.join(Dir.home, ".github-pat")
+        user_file = File.join(Dir.home, ".github-user")
+        if File.exist?(pat_file) && File.exist?(user_file)
+          user = File.read(user_file).strip
+          pat = File.read(pat_file).strip
+          return [user, pat] if !user.empty? && !pat.empty?
+        end
+      end
+
+      # Try ~/.leadfycr (for azurecr.io)
+      if server.end_with?(".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
       end
 
       # Try ~/.docker/config.json

data/lib/kdep/doctor/check.rb

@@ -0,0 +1,15 @@
+module Kdep
+  module Doctor
+    class Check
+      attr_reader :deploy_dir
+
+      def initialize(deploy_dir)
+        @deploy_dir = deploy_dir
+      end
+
+      def run
+        raise NotImplementedError, "#{self.class}#run must be overridden"
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_ancestor_ignores_state.rb

@@ -0,0 +1,26 @@
+require "open3"
+require "kdep/state"
+
+module Kdep
+  module Doctor
+    class CheckAncestorIgnoresState < Check
+      ID = "ancestor_ignores_state".freeze
+
+      def run
+        state_path = File.join(deploy_dir, Kdep::State::FILENAME)
+        _, status = Open3.capture2("git", "check-ignore", "-v", state_path)
+        if status.success?
+          Result.new(
+            id: ID, severity: :error,
+            message: "An ancestor .gitignore is ignoring #{state_path}",
+            hint: "Run 'git check-ignore -v #{state_path}' to find which file, then remove the pattern."
+          )
+        else
+          Result.ok(ID)
+        end
+      rescue Errno::ENOENT
+        Result.ok(ID)
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_gitignore_canonical.rb

@@ -0,0 +1,30 @@
+module Kdep
+  module Doctor
+    class CheckGitignoreCanonical < Check
+      ID = "gitignore_canonical".freeze
+
+      def run
+        path = File.join(deploy_dir, ".gitignore")
+        template_path = File.join(Kdep.templates_dir, "init", "gitignore")
+
+        unless File.exist?(path)
+          return Result.new(
+            id: ID, severity: :info,
+            message: "#{deploy_dir}/.gitignore missing",
+            hint: "Run 'kdep doctor --fix' to create it from the canonical template."
+          )
+        end
+
+        if File.read(path) == File.read(template_path)
+          Result.ok(ID)
+        else
+          Result.new(
+            id: ID, severity: :info,
+            message: "#{path} differs from canonical template",
+            hint: "Review differences; add new entries under the kdep-generated comment."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_state_gitignored.rb

@@ -0,0 +1,26 @@
+require "open3"
+require "kdep/state"
+
+module Kdep
+  module Doctor
+    class CheckStateGitignored < Check
+      ID = "state_gitignored".freeze
+
+      def run
+        state_path = File.join(deploy_dir, Kdep::State::FILENAME)
+        _, status = Open3.capture2("git", "check-ignore", "-q", state_path)
+        if status.success?
+          Result.new(
+            id: ID, severity: :error,
+            message: "#{state_path} is gitignored",
+            hint: "Remove 'state.yml' from .gitignore and 'git add' the file so fresh clones see the last-deployed tag."
+          )
+        else
+          Result.ok(ID)
+        end
+      rescue Errno::ENOENT
+        Result.ok(ID)
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_state_parseable.rb

@@ -0,0 +1,19 @@
+require "kdep/state"
+
+module Kdep
+  module Doctor
+    class CheckStateParseable < Check
+      ID = "state_parseable".freeze
+
+      def run
+        return Result.ok(ID) unless Kdep::State.exists?(deploy_dir)
+        begin
+          Kdep::State.load(deploy_dir)
+          Result.ok(ID)
+        rescue Kdep::State::Error => e
+          Result.new(id: ID, severity: :error, message: e.message)
+        end
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_state_present.rb

@@ -0,0 +1,21 @@
+require "kdep/state"
+
+module Kdep
+  module Doctor
+    class CheckStatePresent < Check
+      ID = "state_present".freeze
+
+      def run
+        if Kdep::State.exists?(deploy_dir)
+          Result.ok(ID)
+        else
+          Result.new(
+            id: ID, severity: :warn,
+            message: "state.yml missing in #{deploy_dir}",
+            hint: "Run 'kdep bump --init-state' to seed, or commit a state.yml manually."
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kdep/doctor/check_state_tag_format.rb

@@ -0,0 +1,20 @@
+require "kdep/state"
+
+module Kdep
+  module Doctor
+    class CheckStateTagFormat < Check
+      ID = "state_tag_format".freeze
+
+      def run
+        return Result.ok(ID) unless Kdep::State.exists?(deploy_dir)
+        tag = Kdep::State.tag(deploy_dir)
+        return Result.ok(ID) if Kdep::State.parseable_tag?(tag)
+        Result.new(
+          id: ID, severity: :warn,
+          message: "state.yml tag #{tag.inspect} is not kdep's major.minor format",
+          hint: "Next 'kdep bump' will fall back to 0.1 for this deploy."
+        )
+      end
+    end
+  end
+end

data/lib/kdep/doctor/result.rb

@@ -0,0 +1,26 @@
+module Kdep
+  module Doctor
+    class Result
+      attr_reader :id, :severity, :message, :hint
+
+      def initialize(id:, severity:, message: nil, hint: nil)
+        @id       = id
+        @severity = severity
+        @message  = message
+        @hint     = hint
+      end
+
+      def ok?
+        @severity == :ok
+      end
+
+      def self.ok(id)
+        new(id: id, severity: :ok)
+      end
+
+      def to_h
+        { id: id, severity: severity, message: message, hint: hint }
+      end
+    end
+  end
+end

data/lib/kdep/doctor.rb

@@ -0,0 +1,21 @@
+require "kdep/doctor/result"
+require "kdep/doctor/check"
+require "kdep/doctor/check_state_present"
+require "kdep/doctor/check_state_parseable"
+require "kdep/doctor/check_state_tag_format"
+require "kdep/doctor/check_state_gitignored"
+require "kdep/doctor/check_gitignore_canonical"
+require "kdep/doctor/check_ancestor_ignores_state"
+
+module Kdep
+  module Doctor
+    CHECKS = [
+      CheckStatePresent,
+      CheckStateParseable,
+      CheckStateTagFormat,
+      CheckStateGitignored,
+      CheckGitignoreCanonical,
+      CheckAncestorIgnoresState,
+    ].freeze
+  end
+end

data/lib/kdep/old_format.rb

@@ -258,8 +258,35 @@ module Kdep
       env
     end
 
+    # Extract the image tag from the live deploy (e.g., "0.44" from
+    # "ghcr.io/org/app:0.44"). Returns nil if the tag is "latest",
+    # empty, or absent. On multi-container deployments, returns the
+    # first usable tag found.
+    def extracted_tag
+      deployed_images.each do |img|
+        parts = img.to_s.split(":", 2)
+        next if parts.length < 2
+        tag = parts[1]
+        next if tag.nil? || tag.empty? || tag == "latest"
+        return tag
+      end
+      nil
+    end
+
     private
 
+    def deployed_images
+      return @deployed_images if defined?(@deployed_images)
+      @deployed_images = []
+      each_manifest do |doc|
+        containers = doc.dig("spec", "template", "spec", "containers") || []
+        containers.each do |c|
+          @deployed_images << c["image"] if c["image"]
+        end
+      end
+      @deployed_images
+    end
+
     def extract_from_manifests(result)
       has_service = false
       has_ingress = false

data/lib/kdep/state.rb

@@ -0,0 +1,48 @@
+require "yaml"
+
+module Kdep
+  module State
+    class Error < StandardError; end
+
+    FILENAME    = "state.yml".freeze
+    INITIAL_TAG = "0.0".freeze
+
+    HEADER = <<~HEADER
+      # Last tag deployed by kdep bump -- do not edit by hand.
+      # This file is safe to commit. See: https://github.com/repleadfy/kdep
+    HEADER
+
+    def self.load(deploy_dir)
+      path = File.join(deploy_dir, FILENAME)
+      return nil unless File.exist?(path)
+      data = YAML.safe_load(File.read(path)) || {}
+      unless data.is_a?(Hash) && data["tag"]
+        raise Error, "#{path}: missing required key 'tag'"
+      end
+      data
+    end
+
+    def self.tag(deploy_dir)
+      loaded = load(deploy_dir)
+      loaded && loaded["tag"]
+    end
+
+    def self.write(deploy_dir, tag:)
+      path = File.join(deploy_dir, FILENAME)
+      tmp  = "#{path}.tmp"
+      content = "#{HEADER}tag: \"#{tag}\"\n"
+      File.write(tmp, content)
+      File.rename(tmp, path)
+      path
+    end
+
+    def self.exists?(deploy_dir)
+      File.exist?(File.join(deploy_dir, FILENAME))
+    end
+
+    def self.parseable_tag?(tag)
+      require "kdep/version_tagger"
+      !!Kdep::VersionTagger.parse(tag)
+    end
+  end
+end

data/lib/kdep/version.rb

@@ -1,3 +1,3 @@
 module Kdep
-  VERSION = "0.3.3"
+  VERSION = "0.3.5"
 end

data/lib/kdep.rb

@@ -17,6 +17,8 @@ require "kdep/docker"
 require "kdep/helm"
 require "kdep/registry"
 require "kdep/version_tagger"
+require "kdep/state"
+require "kdep/doctor"
 require "kdep/commands/render"
 require "kdep/commands/init"
 require "kdep/commands/eject"
@@ -34,6 +36,7 @@ require "kdep/commands/scale"
 require "kdep/commands/migrate"
 require "kdep/commands/helm_install"
 require "kdep/commands/dashboard"
+require "kdep/commands/doctor"
 require "kdep/dashboard/screen"
 require "kdep/dashboard/layout"
 require "kdep/dashboard/panel"

data/templates/init/gitignore

@@ -1,3 +1,4 @@
-# kdep generated files
+# kdep-generated files (do NOT add state.yml -- it is tracked so
+# deploys are reproducible across clones and CI runners).
 secrets.yml
 .rendered/

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdep
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Leadfy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-13 00:00:00.000000000 Z
+date: 2026-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - lib/kdep/commands/bump.rb
 - lib/kdep/commands/dashboard.rb
 - lib/kdep/commands/diff.rb
+- lib/kdep/commands/doctor.rb
 - lib/kdep/commands/eject.rb
 - lib/kdep/commands/helm_install.rb
 - lib/kdep/commands/init.rb
@@ -95,12 +96,22 @@ files:
 - lib/kdep/defaults.rb
 - lib/kdep/discovery.rb
 - lib/kdep/docker.rb
+- lib/kdep/doctor.rb
+- lib/kdep/doctor/check.rb
+- lib/kdep/doctor/check_ancestor_ignores_state.rb
+- lib/kdep/doctor/check_gitignore_canonical.rb
+- lib/kdep/doctor/check_state_gitignored.rb
+- lib/kdep/doctor/check_state_parseable.rb
+- lib/kdep/doctor/check_state_present.rb
+- lib/kdep/doctor/check_state_tag_format.rb
+- lib/kdep/doctor/result.rb
 - lib/kdep/helm.rb
 - lib/kdep/kubectl.rb
 - lib/kdep/old_format.rb
 - lib/kdep/preset.rb
 - lib/kdep/registry.rb
 - lib/kdep/renderer.rb
+- lib/kdep/state.rb
 - lib/kdep/template_context.rb
 - lib/kdep/ui.rb
 - lib/kdep/update_check.rb
@@ -147,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Kubernetes deployment CLI