dev_context 1.0.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 230f85766b6c9c36e855be5be7db4b6c395e813a392d7a4bb55f8f9e5ae43917
-  data.tar.gz: f5fe1a5d23f665c60c2e62f44239ca74bf058bd6eadcb1b93cadccb35c0a6f36
+  metadata.gz: 5acaef7b6cb13adb292bcdbc2f59bff0a659517d3b4d17f36f23b8afb11ee40d
+  data.tar.gz: c5d9cb92a6785bc719b810d66ea18badfd201c2c3fdf9ae438a5e4c41fca6994
 SHA512:
-  metadata.gz: e9bef6e3ecd74e07c89c15e374c414dca442d45947da635d97df64a716949f05fdd0b25b6a4ab6090e5f8f057bf3bd89b60498cca2e7d9cef2ef0be2146d42b1
-  data.tar.gz: d067ebfeb63297953a98452856d853771d2c4d8e0589b00643a007cc70a5ef5b28ccbc4c9a3f1a289113710b0bb18a6e1471e31152d1ec94be17ba1bf80a76b8
+  metadata.gz: e3488671822dfdd73075c1f6c891ec961e62815807313b1fec8d229a70a3fd8867378b7c0089f4e697e3ed17e5fe3e2b0c19bdaea00d214c7df5817a3506f07a
+  data.tar.gz: aa423b93528d9f84023bf40707739cc730c73eecf0a0e0ef45277ca68834a301e25a03195d8a8cd9f7b0da0bd8eff55012b8eefc5730b4f35c90d9456e3a18a4

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [1.1.0] - 2026-05-15
+
+- Add `dx doctor` diagnostics command with `dx check` alias.
+- Add shell integration version marker in `~/.dx.sh` and doctor warning for stale shell script versions.
+- Complete `CLI` modularization by extracting remaining command and support logic into command modules.
+
 ## [0.1.0] - 2026-05-01
 
 - Initial release

data/README.md

@@ -2,19 +2,25 @@
 
 This repo contains `dx` (`dev_context`), a script for managing developer context across repository directories and branches.
 
+> Note: this Ruby implementation now lives in `implementations/ruby` within the
+> multi-language `dev_context` monorepo.
+
 A context is one `(repo_dir, branch)` pair. Context names can be explicit, or implicit as `<repo_basename>:<branch>` (stored lowercase), and resolved with exact then FSF-style fuzzy matching.
 
 ## Installation
 
     gem install -n ~/bin dev_context
 
-Install the gem in the current ruby gem path, with the executable installed as `~/bin/dev_context.rb`.
+Install the gem in the current ruby gem path, with executables installed as:
+
+- `~/bin/dev_context` (launcher, honors `DX_IMPL`)
+- `~/bin/dev_context-ruby` (Ruby implementation entrypoint)
 
 To clone from the github repo:
 
     cd ~/src/github    # or wherever you keep github repos
     git clone https://github.com/aks/dev_context.git
-    cd dev_context
+    cd dev_context/implementations/ruby
     bundle install
     bundle exec rake install
 
@@ -36,16 +42,16 @@ To support `cd`, `dx` should be wrapped by a shell function that evaluates shell
 ```bash
 dx() {
   case "$1" in
-    cd|activate|pushd|popd)
+    cd|activate|pushd|popd|pu|po)
       local out
-      out="$(DX_SHELL_WRAPPED=1 command dev_context.rb "$@")" || return $?
+      out="$(DX_SHELL_WRAPPED=1 command dev_context "$@")" || return $?
       case "$out" in
         "# DX_SHELL_EVAL"*) eval "$out" ;;
         *) printf "%s\n" "$out" ;;
       esac
       ;;
     *)
-      command dev_context.rb "$@"
+      command dev_context "$@"
       ;;
   esac
 }
@@ -81,8 +87,8 @@ dx create -v feature:abc-123 ~/src/github/dev_context feature/abc-123
 
 ### Context stack commands
 
-- `dx pushd CONTEXT|PATH|URL`: activate and push context to top of stack
-- `dx popd [CONTEXT]`: pop the top context (or a specific one); if a new top exists, switch CWD to it
+- `dx pushd [CONTEXT|PATH|URL|+N|-N]`: activate/push context, or rotate indexed stack entry to top
+- `dx popd [CONTEXT|+N|-N]`: pop selected entry; with no args, same as `dx popd +0`
 
 ### `DX_PATH` repo lookup
 
@@ -144,8 +150,8 @@ dx active
 dx activate CONTEXT|PATH|URL
 dx cd CONTEXT|PATH|URL
 dx deactivate CONTEXT
-dx pushd CONTEXT|PATH|URL
-dx popd [CONTEXT]
+dx pushd [CONTEXT|PATH|URL|+N|-N]
+dx popd [CONTEXT|+N|-N]
 dx status|wip [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]
 dx repos [-b BRANCHPATTERN] [-p PATHPATTERN] [PATTERN]
 dx stashes [--list] [PATTERN]

data/bin/dev_context

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/dev_context"
+
+selected_impl = ENV["DX_IMPL"].to_s.strip.downcase
+selected_impl = "ruby" if selected_impl.empty?
+
+if %w[--version -V version].include?(ARGV.first)
+  if selected_impl == "ruby"
+    exit DevContext::CLI.run(ARGV)
+  end
+
+  candidate = "dev_context-#{selected_impl}"
+  begin
+    exec(candidate, *ARGV)
+  rescue Errno::ENOENT
+    warn("dx: selected implementation '#{selected_impl}' is not installed on PATH")
+    warn("dx: expected executable: #{candidate}")
+    warn("dx: set DX_IMPL=ruby or install #{candidate}")
+    exit 127
+  end
+end
+if selected_impl == "ruby"
+  exit DevContext::CLI.run(ARGV)
+end
+
+candidate = "dev_context-#{selected_impl}"
+begin
+  exec(candidate, *ARGV)
+rescue Errno::ENOENT
+  warn("dx: selected implementation not found on PATH: #{candidate}")
+  warn("dx: set DX_IMPL=ruby or install #{candidate}")
+  exit 127
+end

data/lib/dev_context/cli.rb

@@ -12,6 +12,7 @@ module DevContext
     include Commands::Support
     include Commands::ContextLifecycle
     include Commands::GitOps
+    include Commands::Doctor
     include Commands::SearchHelpers
     include Commands::Find
     include Commands::Repos
@@ -27,16 +28,17 @@ module DevContext
     COLOR_YELLOW = "\e[33m"
     COLOR_MAGENTA = "\e[35m"
 
-    def self.run(argv, out: $stdout, err: $stderr, env: ENV, pwd: Dir.pwd)
-      new(argv, out: out, err: err, env: env, pwd: pwd).run
+    def self.run(argv, out: $stdout, err: $stderr, env: ENV, pwd: Dir.pwd, stdin: STDIN)
+      new(argv, out: out, err: err, env: env, pwd: pwd, stdin: stdin).run
     end
 
-    def initialize(argv, out:, err:, env:, pwd:)
+    def initialize(argv, out:, err:, env:, pwd:, stdin: STDIN)
       @argv = argv.dup
       @out = out
       @err = err
       @env = env
       @pwd = pwd
+      @stdin = stdin
       @config = Config.new
       @matcher = Matcher.new(config: @config)
     end
@@ -45,6 +47,7 @@ module DevContext
       raw_command = argv.shift
 
       return default_action if raw_command.nil?
+      raw_command = "version" if %w[--version -V].include?(raw_command)
 
       resolution = resolve_command(raw_command)
       command = resolution[:command]
@@ -62,23 +65,26 @@ module DevContext
       end
 
       case command
-      when "init" then cmd_init
-      when "help", "--help", "-h" then cmd_help
-      when "add" then cmd_add
-      when "clone" then cmd_clone
-      when "create" then cmd_create
-      when "remove" then cmd_remove
-      when "active" then cmd_active
-      when "deactivate" then cmd_deactivate
-      when "find" then cmd_find
-      when "stashes" then cmd_stashes
-      when "repos" then cmd_repos
-      when "status", "wip" then cmd_status(mode: command)
-      when "diff" then cmd_diff
-      when "branches", "br" then cmd_branches
-      when "co", "checkout" then cmd_checkout
-      when "cd", "activate", "pushd" then cmd_activate
-      when "popd" then cmd_pop
+      when "version"                 then cmd_version
+      when "init"                    then cmd_init
+      when "help", "--help", "-h"    then cmd_help
+      when "add"                     then cmd_add
+      when "clone"                   then cmd_clone
+      when "create"                  then cmd_create
+      when "remove"                  then cmd_remove
+      when "active"                  then cmd_active
+      when "deactivate"              then cmd_deactivate
+      when "doctor", "check"         then cmd_doctor
+      when "find"                    then cmd_find
+      when "stashes"                 then cmd_stashes
+      when "repos"                   then cmd_repos
+      when "status", "wip"           then cmd_status(mode: command)
+      when "diff"                    then cmd_diff
+      when "branches", "br"          then cmd_branches
+      when "co", "checkout"          then cmd_checkout
+      when "pushd"                   then cmd_push
+      when "cd", "activate"          then cmd_activate
+      when "popd"                    then cmd_pop
       else
         err.puts("dx: unknown command '#{raw_command}'")
         cmd_help
@@ -88,10 +94,10 @@ module DevContext
 
     private
 
-    attr_reader :argv, :out, :err, :env, :pwd, :config, :matcher
+    attr_reader :argv, :out, :err, :env, :pwd, :stdin, :config, :matcher
 
     COMMANDS = %w[
-      init help add clone create remove active deactivate find repos stashes status wip diff branches br co checkout cd activate pushd popd
+      version init help add clone create remove active deactivate doctor check find repos stashes status wip diff branches br co checkout cd activate pushd popd
     ].freeze
 
     def default_action
@@ -99,5 +105,10 @@ module DevContext
 
       cmd_status
     end
+
+    def cmd_version
+      out.puts("dx #{DevContext::VERSION} (impl: ruby)")
+      0
+    end
   end
 end

data/lib/dev_context/commands/doctor.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+require "open3"
+
+module DevContext
+  module Commands
+    module Doctor
+      def cmd_doctor
+        return usage_error("dx doctor") unless argv.empty?
+
+        checks = []
+        checks.concat(shell_integration_checks)
+        checks.concat(config_structure_checks)
+        checks.concat(repo_integrity_checks)
+        checks.concat(environment_checks)
+
+        label_w = [checks.map { |c| c[:label].length }.max || 0, "Check".length].max
+        state_w = [checks.map { |c| c[:state].length }.max || 0, "State".length].max
+
+        out.puts(format("%-#{state_w}s  %-#{label_w}s  %s", "State", "Check", "Message"))
+        out.puts(format("%-#{state_w}s  %-#{label_w}s  %s", "-" * state_w, "-" * label_w, "-" * 7))
+        checks.each do |check|
+          out.puts(format("%-#{state_w}s  %-#{label_w}s  %s", check[:state], check[:label], check[:message]))
+        end
+
+        failures = checks.count { |c| c[:state] == "FAIL" }
+        warnings = checks.count { |c| c[:state] == "WARN" }
+        out.puts
+        out.puts("doctor summary: #{checks.length} checks, #{failures} failures, #{warnings} warnings")
+
+        failures.zero? ? 0 : 1
+      end
+
+      private
+
+      def shell_integration_checks
+        checks = []
+        shell_path = env.fetch("DX_SHELL_PATH", ShellSetup::DEFAULT_PATH)
+        if File.exist?(shell_path)
+          content = File.read(shell_path)
+          if content.include?(ShellSetup::MANAGED_MARKER)
+            checks << ok_check("shell-script", "Found managed shell integration at #{shell_path}")
+            checks << ok_check("shell-managed", "Shell integration is managed by dx init")
+            shell_version = extract_shell_script_version(content)
+            if shell_version.nil?
+              checks << warn_check("shell-version", "Managed shell integration is missing version marker")
+            elsif shell_version == DevContext::SHELL_VERSION
+              checks << ok_check("shell-version", "Shell integration matches shell version #{DevContext::SHELL_VERSION}")
+            else
+              checks << warn_check("shell-version", "Shell integration is #{shell_version}; current shell version is #{DevContext::SHELL_VERSION} (run `dx init`)")
+            end
+          else
+            checks << warn_check("shell-script", "Shell file exists but is unmanaged: #{shell_path}")
+          end
+        else
+          checks << fail_check("shell-script", "Shell integration file missing: #{shell_path} (run `dx init`)")
+        end
+        checks
+      end
+
+      def config_structure_checks
+        checks = []
+        if config.initialized?
+          checks << ok_check("config-file", "Config file exists at #{config.path}")
+        else
+          checks << fail_check("config-file", "Config file missing at #{config.path} (run `dx init`)")
+          return checks
+        end
+
+        active_missing = config.active_stack.reject { |name| config.contexts.key?(name) }
+        if active_missing.empty?
+          checks << ok_check("active-stack", "Active stack entries map to known contexts")
+        else
+          checks << fail_check("active-stack", "Active stack has missing contexts: #{active_missing.join(', ')}")
+        end
+        checks
+      end
+
+      def repo_integrity_checks
+        paths = config.repos.values.map { |repo| repo["path"] }.compact.uniq
+        return [warn_check("known-repos", "No known repos in config")] if paths.empty?
+
+        missing = []
+        non_git = []
+        paths.each do |path|
+          expanded = File.expand_path(path)
+          unless File.directory?(expanded)
+            missing << expanded
+            next
+          end
+          non_git << expanded unless git_repo?(expanded)
+        end
+
+        checks = []
+        if missing.empty?
+          checks << ok_check("repo-paths", "All known repo paths exist")
+        else
+          checks << fail_check("repo-paths", "Missing repo paths: #{missing.join(', ')}")
+        end
+
+        if non_git.empty?
+          checks << ok_check("git-repos", "All existing known repos are git repos")
+        else
+          checks << warn_check("git-repos", "Non-git known paths: #{non_git.join(', ')}")
+        end
+        checks
+      end
+
+      def environment_checks
+        checks = []
+
+        found_exec = command_success?("sh", "-lc", "command -v dev_context >/dev/null 2>&1")
+        if found_exec
+          checks << ok_check("executable", "`dev_context` is on PATH")
+          if command_success?("dev_context", "help")
+            checks << ok_check("executable-run", "`dev_context help` executes successfully")
+          else
+            checks << warn_check("executable-run", "`dev_context` found but failed to execute `help`")
+          end
+        else
+          checks << warn_check("executable", "`dev_context` not found on PATH")
+        end
+
+        dx_path_raw = env["DX_PATH"]
+        if dx_path_raw.to_s.strip.empty?
+          checks << warn_check("DX_PATH", "DX_PATH is not set")
+        else
+          roots = dx_path_raw.split(/[:;]/).flat_map { |entry| Dir.glob(File.expand_path(entry.to_s.strip)) }.uniq
+          dirs = roots.select { |entry| File.directory?(entry) }
+          if dirs.empty?
+            checks << warn_check("DX_PATH", "No valid directories resolved from DX_PATH")
+          else
+            checks << ok_check("DX_PATH", "Resolved #{dirs.length} directory root(s)")
+          end
+        end
+
+        checks
+      end
+
+      def ok_check(label, message)
+        { state: "OK", label: label, message: message }
+      end
+
+      def warn_check(label, message)
+        { state: "WARN", label: label, message: message }
+      end
+
+      def fail_check(label, message)
+        { state: "FAIL", label: label, message: message }
+      end
+
+      def extract_shell_script_version(content)
+        escaped = Regexp.escape(ShellSetup::VERSION_MARKER_PREFIX)
+        match = content.match(/^\s*#\s*#{escaped}\s+(.+?)\s*$/)
+        return nil unless match
+
+        match[1]
+      end
+
+      def command_success?(*cmd)
+        _out, status = Open3.capture2e(env.to_h, *cmd)
+        status.success?
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/dev_context/commands/git_ops.rb

@@ -29,8 +29,34 @@ module DevContext
         0
       end
 
+      def cmd_push
+        target = argv.shift
+        return usage_error("dx pushd [CONTEXT|+N|-N]") unless argv.empty?
+
+        if target&.match?(/\A[+-]\d+\z/)
+          return rotate_active_stack_to(target)
+        end
+
+        return usage_error("dx pushd [CONTEXT|+N|-N]") if blank?(target)
+
+        context, code = resolve_or_create_context(target)
+        return code unless code.zero?
+
+        config.activate_context!(context.fetch("name"))
+        script = ShellEmitter.new(
+          context: context,
+          remote_name: env.fetch("DX_GIT_REMOTE_NAME", "USE-REPO"),
+          auto_create_local_branch: truthy?(env.fetch("DX_AUTO_CREATE_LOCAL_BRANCH", "true"))
+        ).activation_script
+        out.write(script)
+        0
+      end
+
       def cmd_pop
         target = argv.shift
+        return usage_error("dx popd [CONTEXT|+N|-N]") unless argv.empty?
+        return pop_by_stack_index("+0") if target.nil?
+        return pop_by_stack_index(target) if target.match?(/\A[+-]\d+\z/)
 
         if target
           context = matcher.resolve(target)
@@ -158,6 +184,72 @@ module DevContext
         out.puts("Checked out #{feature} in #{context_name}")
         0
       end
+
+      private
+
+      def rotate_active_stack_to(token)
+        stack = config.active_stack
+        return no_active_contexts if stack.empty?
+
+        idx = parse_stack_index_token(token, stack.length)
+        if idx.nil?
+          err.puts("dx: invalid stack index '#{token}'")
+          return 2
+        end
+
+        context_name = stack[idx]
+        context = config.contexts[context_name]
+        unless context
+          err.puts("dx: active stack entry is missing context: #{context_name}")
+          return 1
+        end
+
+        config.activate_context!(context_name)
+        script = ShellEmitter.new(
+          context: context,
+          remote_name: env.fetch("DX_GIT_REMOTE_NAME", "USE-REPO"),
+          auto_create_local_branch: truthy?(env.fetch("DX_AUTO_CREATE_LOCAL_BRANCH", "true"))
+        ).activation_script
+        out.write(script)
+        0
+      end
+
+      def pop_by_stack_index(token)
+        stack = config.active_stack
+        return no_active_contexts if stack.empty?
+
+        idx = parse_stack_index_token(token, stack.length)
+        if idx.nil?
+          err.puts("dx: invalid stack index '#{token}'")
+          return 2
+        end
+
+        context_name = stack.delete_at(idx)
+        context = config.contexts[context_name]
+        config.send(:save!)
+        out.puts("Popped #{context ? context.fetch('name') : context_name}")
+
+        new_top = config.active_contexts.first
+        return 0 unless new_top
+
+        out.puts("cd #{Shellwords.escape(new_top.fetch('repo_path'))}")
+        0
+      end
+
+      def parse_stack_index_token(token, stack_size)
+        return nil unless token.match?(/\A[+-]\d+\z/)
+
+        n = token[1..].to_i
+        idx = token.start_with?("+") ? n : (stack_size - 1 - n)
+        return nil if idx.negative? || idx >= stack_size
+
+        idx
+      end
+
+      def no_active_contexts
+        out.puts("No active contexts")
+        0
+      end
     end
   end
 end

data/lib/dev_context/commands/help.rb

@@ -25,15 +25,17 @@ module DevContext
             dx checkout|co [-b] FEATURE [CONTEXT]
             dx clone URL [PATH]
             dx create NAME [PATH] [BRANCH]
+            dx doctor|check
             dx deactivate CONTEXT
             dx diff [CONTEXT]
             dx find [--stashes|--branches|--paths] <pattern>
             dx find --all
             dx <pattern>  # shorthand for: dx find <pattern>
             dx help
-            dx init
-            dx popd [CONTEXT]
-            dx pushd CONTEXT|PATH|URL
+            dx init [ruby|go|elixir]
+            dx version
+            dx popd [CONTEXT|+N|-N]
+            dx pushd [CONTEXT|PATH|URL|+N|-N]
             dx repos [PATTERN]
             dx remove CONTEXT|PATH
             dx stashes [--list] [PATTERN]
@@ -52,16 +54,24 @@ module DevContext
                  "Usage: dx stashes [--list] [PATTERN]\n\nShow repos with stashes. Provide PATTERN to filter stash titles; use --list to print matching entries."
                when "find"
                  "Usage: dx find [--stashes|--branches|--paths] <pattern>\n       dx find --all\n\nSearch stash titles, branches, and repo paths. Use --all to show likely-forgotten work."
+               when "doctor", "check"
+                 "Usage: dx doctor\n       dx check\n\nRun environment and config diagnostics."
+               when "init"
+                 "Usage: dx init [ruby|go|elixir]\n\nInitialize dx files. If IMPL is given, set DX_IMPL non-interactively."
+               when "version"
+                 "Usage: dx version\n       dx --version\n       dx -V\n\nPrint the active dx implementation and version."
                when "add"
                  "Usage: dx add [-c NAME] [-n] [-v] PATH|URL ..."
                when "clone"
                  "Usage: dx clone [-c NAME] [-n] [-v] URL [PATH]"
                when "create"
                  "Usage: dx create [-c NAME] [-n] [-v] NAME [PATH] [BRANCH]"
-               when "activate", "cd", "pushd"
+               when "activate", "cd"
                  "Usage: dx #{command} CONTEXT|PATH|URL"
+               when "pushd"
+                 "Usage: dx pushd [CONTEXT|PATH|URL|+N|-N]\n\nCONTEXT accepts exact or fuzzy-matched context names. PATH and URL resolve/create contexts. +N/-N select existing active-stack entries (+0 top/left, -0 bottom/right) and rotate that entry to top."
                when "popd"
-                 "Usage: dx popd [CONTEXT]"
+                 "Usage: dx popd [CONTEXT|+N|-N]\n\nWith no args, same as `dx popd +0`. CONTEXT accepts exact or fuzzy-matched context names. +N counts from top/left (+0 top), -N from bottom/right (-0 bottom)."
                when "remove"
                  "Usage: dx remove CONTEXT|PATH"
                when "diff"

data/lib/dev_context/commands/init.rb

@@ -4,6 +4,13 @@ module DevContext
   module Commands
     module Init
       def cmd_init
+        explicit_impl = argv.shift
+        return usage_error("dx init [ruby|go|elixir]") unless argv.empty?
+        if explicit_impl && !valid_impl?(explicit_impl)
+          err.puts("dx: unknown implementation '#{explicit_impl}'")
+          return usage_error("dx init [ruby|go|elixir]")
+        end
+
         created = config.init!
         shell_status = ShellSetup.new.install!
 
@@ -15,8 +22,61 @@ module DevContext
                         end
         out.puts(shell_message)
         out.puts('Add `source ~/.dx.sh` to ~/.zshrc or ~/.bashrc')
+        impl = if explicit_impl
+                 explicit_impl.downcase
+               elsif stdin.tty?
+                 prompt_dx_impl
+               end
+        if impl
+          updated_files = persist_dx_impl_choice(impl)
+          out.puts("Set DX_IMPL=#{impl} in #{updated_files.join(', ')}")
+        end
         0
       end
+
+      private
+
+      def prompt_dx_impl
+        out.print("Choose DX implementation [ruby/go/elixir] (default: ruby): ")
+        raw = stdin.gets.to_s.strip.downcase
+        return "ruby" if raw.empty?
+        return raw if valid_impl?(raw)
+
+        err.puts("dx: unknown implementation '#{raw}', defaulting to ruby")
+        "ruby"
+      end
+
+      def valid_impl?(value)
+        %w[ruby go elixir].include?(value.to_s.strip.downcase)
+      end
+
+      def persist_dx_impl_choice(choice)
+        home = env.fetch("HOME", File.expand_path("~"))
+        zshrc = File.join(home, ".zshrc")
+        bashrc = File.join(home, ".bashrc")
+        preferred = env.fetch("SHELL", "").include?("bash") ? bashrc : zshrc
+        existing = [zshrc, bashrc].select { |path| File.exist?(path) }
+        targets = existing.empty? ? [preferred] : existing
+
+        targets.each { |path| write_dx_impl_to_rc(path, choice) }
+        targets
+      end
+
+      def write_dx_impl_to_rc(path, choice)
+        line = "export DX_IMPL=#{choice}"
+        current = File.exist?(path) ? File.read(path) : ""
+        updated =
+          if current.match?(/^\s*(?:export\s+)?DX_IMPL=.*$/)
+            current.gsub(/^\s*(?:export\s+)?DX_IMPL=.*$/, line)
+          elsif current.empty?
+            "#{line}\n"
+          elsif current.end_with?("\n")
+            "#{current}#{line}\n"
+          else
+            "#{current}\n#{line}\n"
+          end
+        File.write(path, updated)
+      end
     end
   end
 end

data/lib/dev_context/commands/support.rb

@@ -280,8 +280,9 @@ module DevContext
       end
 
       def render_status_table(rows)
-        display_rows = rows.map do |row|
-          row.merge(path: display_path(row[:path]))
+        display_rows = rows.each_with_index.map do |row, idx|
+          indexed_path = "[#{idx}] #{display_path(row[:path])}"
+          row.merge(path: indexed_path)
         end
 
         path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Path".length].max

data/lib/dev_context/shell_setup.rb

@@ -4,6 +4,7 @@ module DevContext
   class ShellSetup
     DEFAULT_PATH = File.expand_path("~/.dx.sh").freeze
     MANAGED_MARKER = "DevContext shell integration generated by `dx init`".freeze
+    VERSION_MARKER_PREFIX = "DX Shell Version:".freeze
 
     attr_reader :path
 
@@ -36,20 +37,33 @@ module DevContext
       <<~SH
         #!/usr/bin/env sh
         # #{MANAGED_MARKER}
+        # #{VERSION_MARKER_PREFIX} #{DevContext::SHELL_VERSION}
         # shellcheck shell=sh
 
         dx() {
+          local bin
+          case "${DX_IMPL:-go}" in
+            go)
+              bin=dev_context-go ;;
+            ruby)
+              bin=dev_context.rb ;;
+            elixir)
+              bin=dev_context-ex ;;
+            *)
+              echo 1>&2 "No idea what $DX_IMPL means!" ; exit 1 ;;
+          esac
+          local out
           case "$1" in
             cd|activate|pushd|popd)
               local out
-              out="$(DX_SHELL_WRAPPED=1 command dev_context.rb "$@")" || return $?
+              out="$(DX_SHELL_WRAPPED=1 command $bin "$@")" || return $?
               case "$out" in
                 "# DX_SHELL_EVAL"*) eval "$out" ;;
                 *) printf "%s\\n" "$out" ;;
               esac
               ;;
             *)
-              command dev_context.rb "$@"
+              command $bin "$@"
               ;;
           esac
         }

data/lib/dev_context/version.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 module DevContext
+  SHELL_VERSION = "1"
   RELEASES = [
-    ["1.0.1", '2026-05-12']
+    ["1.0.1", '2026-05-12'],
+    ["1.1.0", '2026-05-15'],
+    ["1.2.1", '2026-05-26']
   ].freeze
   VERSION = RELEASES.last.first
 end

data/lib/dev_context.rb

@@ -8,6 +8,7 @@ require_relative "dev_context/commands/help"
 require_relative "dev_context/commands/support"
 require_relative "dev_context/commands/context_lifecycle"
 require_relative "dev_context/commands/git_ops"
+require_relative "dev_context/commands/doctor"
 require_relative "dev_context/commands/find"
 require_relative "dev_context/commands/search_helpers"
 require_relative "dev_context/commands/repos"

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dev_context
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Alan Stebbens
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuubar
@@ -53,12 +54,13 @@ dependencies:
         version: '3.0'
 description: |
   DevContext (aka `dx`) is a developer context manager that unifies directory-level context
-  switching, multi-repo awareness, and Git-aware introspection. It helps you manage multiple
-  active projects with an activation stack.
+  switching, branch awareness, multi-repo awareness, and Git-aware introspection. It helps
+  you manage multiple active projects with an active stack.
 email:
 - aks@stebbens.org
 executables:
-- dev_context.rb
+- dev_context
+- dev_context-ruby
 extensions: []
 extra_rdoc_files: []
 files:
@@ -68,11 +70,13 @@ files:
 - LICENSE.txt
 - README.md
 - bin/console
-- bin/dev_context.rb
+- bin/dev_context
+- bin/dev_context-ruby
 - bin/setup
 - lib/dev_context.rb
 - lib/dev_context/cli.rb
 - lib/dev_context/commands/context_lifecycle.rb
+- lib/dev_context/commands/doctor.rb
 - lib/dev_context/commands/find.rb
 - lib/dev_context/commands/git_ops.rb
 - lib/dev_context/commands/help.rb
@@ -96,6 +100,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   source_code_uri: https://github.com/aks/dev_context
   changelog_uri: https://github.com/aks/dev_context/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,7 +115,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A developer context manager for multi-repo workflows
 test_files: []