kdep 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 615a9eb7f9d29743543c3af91b7a40bb1c3144246b5610dfa87c0d56263daed3
-  data.tar.gz: 17c34cf62596baeba616c1648c6013e499c73b6ad05f602bafb8d116287487f5
+  metadata.gz: 8194d84a25eda1737a9bdab8891db08ec092cfc71c86764fac24ff044b977626
+  data.tar.gz: d247a4155dea0105240416bf2af475d5a7e22b71917467f230bc13123d4c79b5
 SHA512:
-  metadata.gz: 5daa74dd82e2dcc8bb3001d62fe03bf89d32cb96d004bbd303b0ef568c6881fc6d32cbb76fae4191c0df469c70051737996e363762712a08f1d27ff1d95a92fd
-  data.tar.gz: 3061858aa0b926fce8bf3aadbc7cf047e01376e7e1206756b4233764efaca656e7dbc10966cff22233124963048db59113cd04dbc7ce796bfa94830072d2e17e
+  metadata.gz: e3fb390e4470e4daf795717de1cac5c32142eb208dc58e529eabccba079bfeb2dd737ee74ad92ea92a675298911091dbd52ea007f9c38cbc8e624ea8d0bbf13d
+  data.tar.gz: 36e1bc46602c74aa2027e0c4377b951d0602ce24ca05470f2f0a989fe6266288da5017f3f45e91d3923efe1e884830709718a7b75aa5db8fa3c3408e20f8e2a4

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
 
@@ -43,7 +44,24 @@ module Kdep
 
         config = Kdep::Config.new(deploy_dir, env).load
 
-        # Step 2: Context guard (bump touches the cluster)
+        # Step 2: Local config sanity — read state.yml BEFORE touching the
+        # cluster. A missing/corrupt state.yml is a local config error and
+        # should fail fast without waking kubectl.
+        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
+
+        # Step 3: Context guard (bump touches the cluster)
         begin
           Kdep::ContextGuard.new(config["context"]).validate!
         rescue Kdep::Kubectl::Error => e
@@ -63,14 +81,7 @@ module Kdep
         repo_root = File.dirname(kdep_dir)
 
         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"
-          end
+          # Step 4: Increment minor version.
           parsed = Kdep::VersionTagger.parse(current_tag)
           next_version = parsed ? "#{parsed[0]}.#{parsed[1] + 1}" : "0.1"
           @ui.info("#{current_tag} -> #{next_version}")
@@ -159,7 +170,7 @@ module Kdep
               @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}))
+              Kdep::State.write(deploy_dir, tag: next_version)
 
               # Launch TUI dashboard for live monitoring
               unless @command_options[:"no-dashboard"]
@@ -185,6 +196,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/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_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,28 @@
+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)
+        # capture3 swallows stderr so "fatal: not a git repository" noise
+        # never reaches the user when the caller runs outside a repo.
+        _, _, status = Open3.capture3("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 any .gitignore (local or ancestor) 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,19 @@
+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"
+
+module Kdep
+  module Doctor
+    CHECKS = [
+      CheckStatePresent,
+      CheckStateParseable,
+      CheckStateTagFormat,
+      CheckStateGitignored,
+      CheckGitignoreCanonical,
+    ].freeze
+  end
+end

data/lib/kdep/old_format.rb

@@ -258,8 +258,41 @@ 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. Uses rpartition so registry URLs with
+    # explicit ports (host:5000/org/app:0.44) aren't misparsed.
+    def extracted_tag
+      deployed_images.each do |img|
+        before, sep, after = img.to_s.rpartition(":")
+        # rpartition returns ["", "", img] when no ":" exists
+        next if sep.empty?
+        # A host:port with no tag (e.g. "host:5000/img") has sep but the
+        # "tag" part contains a "/" — not a real tag.
+        next if after.empty? || after.include?("/")
+        next if after == "latest"
+        # before will include any host:port prefix intact
+        _ = before
+        return after
+      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.4"
+  VERSION = "0.3.6"
 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.4
+  version: 0.3.6
 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,21 @@ 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_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