dev_context 1.0.0

data/lib/dev_context/commands/status.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Status
+      def cmd_status(mode: "status")
+        args = argv.dup
+        all = false
+        dirty_only = (mode == "wip")
+        branch_pattern = nil
+        path_pattern = nil
+        parser = OptionParser.new
+        parser.on("-a", "--all", "Show status for all known repos") { all = true }
+        parser.on("-d", "--dirty", "Show only repos that are not up to date") { dirty_only = true }
+        parser.on("-b", "--branch BRANCHPATTERN", "Filter by branch pattern") { |v| branch_pattern = v }
+        parser.on("-p", "--path PATHPATTERN", "Filter by path pattern") { |v| path_pattern = v }
+        parser.parse!(args)
+        usage = mode == "wip" ? "dx wip [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]" : "dx status [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]"
+        return usage_error(usage) unless args.empty?
+
+        rows = all ? all_known_repo_rows : active_context_rows
+        rows = rows.select { |row| pattern_match?(row[:branch], branch_pattern) }
+        rows = rows.select { |row| pattern_match?(row[:path], path_pattern) }
+        rows = rows.reject { |row| strip_ansi(row[:status]).start_with?("Up to date") } if dirty_only
+        if rows.empty?
+          out.puts(empty_message(all: all, dirty_only: dirty_only))
+          return 0
+        end
+
+        render_status_table(rows)
+        0
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error(mode == "wip" ? "dx wip [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]" : "dx status [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]")
+      end
+
+      private
+
+      def active_context_rows
+        config.active_contexts.map do |ctx|
+          stash_count = stash_count(ctx.fetch("repo_path"))
+          base_status = ::DevContext::Status.new(repo_path: ctx.fetch("repo_path")).one_line
+          {
+            path: ctx.fetch("repo_path"),
+            branch: ctx.fetch("branch"),
+            status: colorize_status(compact_status(with_stash(base_status, stash_count)))
+          }
+        end
+      end
+
+      def all_known_repo_rows
+        config.repos.values.map { |repo| repo["path"] }.uniq.filter_map do |path|
+          expanded = File.expand_path(path)
+          next unless File.directory?(expanded)
+          stash = stash_count(expanded)
+          base_status = ::DevContext::Status.new(repo_path: expanded).one_line
+
+          {
+            path: expanded,
+            branch: current_branch(expanded) || "-",
+            status: colorize_status(compact_status(with_stash(base_status, stash)))
+          }
+        end
+      end
+
+      def strip_ansi(text)
+        text.to_s.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def empty_message(all:, dirty_only:)
+        return "No dirty repos" if all && dirty_only
+        return "No dirty active contexts" if dirty_only
+        return "No known repos" if all
+
+        "No active contexts"
+      end
+
+      def stash_count(repo_path)
+        stash_entries(repo_path).length
+      end
+
+      def with_stash(status, stash_count)
+        return status if stash_count.to_i.zero?
+
+        "#{status} s:#{stash_count}"
+      end
+
+      def compact_status(status)
+        return status if status.start_with?("Up to date")
+
+        filtered = status
+          .split
+          .reject { |token| token.match?(/\A[a-z]:0\z/) }
+
+        filtered.empty? ? "Up to date" : filtered.join(" ")
+      end
+
+    end
+  end
+end

data/lib/dev_context/commands/support.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Support
+      private
+
+      def current_branch(repo_path)
+        cmd = %(git -C "#{File.expand_path(repo_path)}" rev-parse --abbrev-ref HEAD 2>/dev/null)
+        branch = `#{cmd}`.strip
+        return nil unless $?.success?
+
+        branch
+      end
+
+      def resolve_or_create_context(target)
+        existing = matcher.resolve(target)
+        return [existing, 0] if existing
+
+        if url?(target)
+          code = clone_and_register!(target, explicit_path: nil, explicit_name: nil, opts: {})
+          return [nil, code] unless code.zero?
+
+          destination = clone_destination(target, nil)
+          context = config.contexts.values.find { |ctx| ctx["repo_path"] == destination }
+          return [context, 0] if context
+
+          return [nil, not_found(target)]
+        end
+
+        resolved = resolve_repo_path_target(target)
+        return [nil, resolved.fetch(:code)] unless resolved.fetch(:code).zero?
+
+        repo_path = resolved.fetch(:path)
+        return [nil, repo_not_found(repo_path)] unless File.directory?(repo_path)
+
+        unless git_repo?(repo_path)
+          init_code = ensure_git_repo!(repo_path)
+          return [nil, init_code] unless init_code.zero?
+        end
+
+        branch = current_branch(repo_path) || "main"
+        context_name = config.add_context(
+          name: implicit_context_name(repo_path, branch),
+          repo_path: repo_path,
+          branch: branch
+        )
+        [config.get_context(context_name), 0]
+      end
+
+      def clone_and_register!(url, explicit_path:, explicit_name: nil, opts: {})
+        destination = clone_destination(url, explicit_path)
+        destination_parent = File.dirname(destination)
+        if opts[:norun]
+          out.puts("Would clone #{url} -> #{destination}")
+          out.puts("Would register context #{(explicit_name || implicit_context_name(destination, 'main')).downcase}")
+          return 0
+        end
+
+        FileUtils.mkdir_p(destination_parent) unless File.directory?(destination_parent)
+
+        if File.exist?(destination)
+          return non_git_path(destination) unless git_repo?(destination)
+        else
+          clone_cmd = %(git clone #{Shellwords.escape(url)} #{Shellwords.escape(destination)} 2>&1)
+          clone_output = `#{clone_cmd}`
+          unless $?.success?
+            err.puts("dx: clone failed for #{url}")
+            err.puts(clone_output)
+            return 21
+          end
+        end
+
+        branch = current_branch(destination) || "main"
+        context_name = config.add_context(
+          name: explicit_name || implicit_context_name(destination, branch),
+          repo_path: destination,
+          branch: branch
+        )
+        out.puts("Clone destination: #{destination}") if opts[:verbose]
+        out.puts("Cloned/added context #{context_name} -> #{destination} @ #{branch}")
+        0
+      end
+
+      def add_single_target(target, explicit_context: nil, opts: {})
+        if url?(target)
+          return clone_and_register!(target, explicit_path: nil, explicit_name: explicit_context, opts: opts)
+        end
+
+        resolved = resolve_repo_path_target(target)
+        return resolved.fetch(:code) unless resolved.fetch(:code).zero?
+
+        repo_path = resolved.fetch(:path)
+        return repo_not_found(repo_path) unless File.directory?(repo_path)
+        if opts[:norun]
+          branch_preview = current_branch(repo_path) || "main"
+          preview_name = explicit_context || implicit_context_name(repo_path, branch_preview)
+          out.puts("Would add context #{preview_name.downcase} -> #{repo_path} @ #{branch_preview}")
+          return 0
+        end
+
+        unless git_repo?(repo_path)
+          init_code = ensure_git_repo!(repo_path)
+          return init_code unless init_code.zero?
+        end
+
+        branch = current_branch(repo_path) || "main"
+        context_name = config.add_context(
+          name: explicit_context || implicit_context_name(repo_path, branch),
+          repo_path: repo_path,
+          branch: branch
+        )
+        out.puts("Resolved path: #{repo_path}") if opts[:verbose]
+        out.puts("Added context #{context_name} -> #{repo_path} @ #{branch}")
+        0
+      end
+
+      def resolve_repo_path_target(target)
+        direct = File.expand_path(target, pwd)
+        return { code: 0, path: direct } if File.directory?(direct)
+
+        matches = path_search_roots
+          .map { |root| File.expand_path(target, root) }
+          .select { |candidate| File.directory?(candidate) }
+          .uniq
+
+        return { code: 0, path: matches.first } if matches.length == 1
+
+        if matches.length > 1
+          err.puts("dx: '#{target}' is ambiguous in DX_PATH:")
+          matches.each { |match| err.puts("  - #{match}") }
+          return { code: 26 }
+        end
+
+        fsf_matches = fsf_repo_matches(target)
+        return { code: 0, path: fsf_matches.first } if fsf_matches.length == 1
+
+        if fsf_matches.length > 1
+          err.puts("dx: '#{target}' is ambiguous by FSF search across DX_PATH/DX_CLONE_BASE_DIR:")
+          fsf_matches.each { |match| err.puts("  - #{match}") }
+          return { code: 27 }
+        end
+
+        { code: 0, path: direct }
+      end
+
+      def parse_common_flags!(args, allow_context:, allow_norun:)
+        opts = { context: nil, norun: false, verbose: false }
+        parser = OptionParser.new
+        parser.on("-v", "--verbose", "Verbose output") { opts[:verbose] = true }
+        parser.on("-n", "--norun", "Preview actions without mutating state") do
+          raise OptionParser::InvalidOption, "--norun not supported for this command" unless allow_norun
+
+          opts[:norun] = true
+        end
+        parser.on("-cNAME", "--context=NAME", "Explicit context name") do |name|
+          raise OptionParser::InvalidOption, "--context not supported for this command" unless allow_context
+
+          opts[:context] = config.normalize_name(name)
+        end
+        parser.parse!(args)
+        opts
+      end
+
+      def clone_destination(url, explicit_path)
+        suffix = explicit_path || url_basename(url)
+        return File.expand_path(suffix) if Pathname.new(suffix).absolute?
+
+        File.expand_path(suffix, clone_base_dir)
+      end
+
+      def clone_base_dir
+        configured = env["DX_CLONE_BASE_DIR"]
+        return File.expand_path(configured) if configured && File.directory?(File.expand_path(configured))
+
+        pwd
+      end
+
+      def dx_path_roots
+        raw = env["DX_PATH"]
+        return [] if blank?(raw)
+
+        raw.split(/[:;]/)
+          .flat_map { |entry| Dir.glob(File.expand_path(entry.to_s.strip)) }
+          .select { |entry| File.directory?(entry) }
+          .uniq
+      end
+
+      def path_search_roots
+        roots = dx_path_roots.dup
+        clone_root = env["DX_CLONE_BASE_DIR"]
+        if clone_root
+          expanded = File.expand_path(clone_root)
+          roots << expanded if File.directory?(expanded)
+        end
+        roots.uniq
+      end
+
+      def fsf_repo_matches(query)
+        normalized = query.to_s.downcase
+        path_search_roots.flat_map do |root|
+          Dir.children(root).filter_map do |entry|
+            candidate = File.join(root, entry)
+            next unless File.directory?(candidate)
+            next unless fsf_subsequence?(normalized, entry.downcase)
+
+            candidate
+          end
+        rescue Errno::ENOENT, Errno::EACCES
+          []
+        end.uniq
+      end
+
+      def fsf_subsequence?(needle, haystack)
+        return false if needle.empty?
+
+        i = 0
+        haystack.each_char do |ch|
+          i += 1 if i < needle.length && needle[i] == ch
+        end
+        i == needle.length
+      end
+
+      def url?(value)
+        value.match?(%r{\A[a-z][a-z0-9+\-.]*://}i) || value.start_with?("git@")
+      end
+
+      def url_basename(url)
+        base = url.split("/").last.to_s
+        base = base.split(":").last if base.empty?
+        base.sub(/\.git\z/, "")
+      end
+
+      def implicit_context_name(repo_path, branch)
+        "#{File.basename(repo_path)}:#{branch}".downcase
+      end
+
+      def git_repo?(path)
+        cmd = %(git -C "#{path}" rev-parse --is-inside-work-tree >/dev/null 2>&1)
+        system(cmd)
+      end
+
+      def ensure_git_repo!(repo_path)
+        if truthy?(env.fetch("DX_NO_GIT_INIT", "false"))
+          err.puts("dx: #{repo_path} is not a git repository; set DX_NO_GIT_INIT=false or run `git init #{repo_path}`")
+          return 23
+        end
+
+        init_cmd = %(git -C "#{repo_path}" init >/dev/null 2>&1)
+        unless system(init_cmd)
+          err.puts("dx: failed to initialize git repository at #{repo_path}")
+          return 24
+        end
+
+        out.puts("Initialized git repository at #{repo_path}")
+        0
+      end
+
+      def blank?(value)
+        value.to_s.strip.empty?
+      end
+
+      def truthy?(value)
+        %w[1 true yes y on].include?(value.to_s.strip.downcase)
+      end
+
+      def not_found(target)
+        err.puts("dx: could not resolve context/path '#{target}'")
+        1
+      end
+
+      def repo_not_found(path)
+        err.puts("dx: repository path does not exist: #{path}")
+        1
+      end
+
+      def non_git_path(path)
+        err.puts("dx: destination exists but is not a git repository: #{path}")
+        22
+      end
+
+      def render_status_table(rows)
+        display_rows = rows.map do |row|
+          row.merge(path: display_path(row[:path]))
+        end
+
+        path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Path".length].max
+        branch_w = [rows.map { |r| r[:branch].length }.max || 0, "Branch".length].max
+
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s  %s", "Path", "Branch", "Status"))
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s  %s", "-" * path_w, "-" * branch_w, "-" * 6))
+        display_rows.each do |row|
+          out.puts(format("%-#{path_w}s  %-#{branch_w}s  %s", row[:path], row[:branch], row[:status]))
+        end
+      end
+
+      def display_path(path)
+        home = File.expand_path("~")
+        expanded = File.expand_path(path)
+        return "~" if expanded == home
+        return expanded unless expanded.start_with?("#{home}/")
+
+        expanded.sub(home, "~")
+      end
+
+      def colorize_status(status)
+        return status unless color_output?
+        color_orange = self.class::COLOR_ORANGE
+        color_cyan = self.class::COLOR_CYAN
+        color_green = self.class::COLOR_GREEN
+        color_red = self.class::COLOR_RED
+        color_yellow = self.class::COLOR_YELLOW
+        color_magenta = self.class::COLOR_MAGENTA
+        color_reset = self.class::COLOR_RESET
+        return "#{color_green}Up to date#{color_reset}" if status == "Up to date"
+
+        status
+          .gsub(/\bm:\d+\b/, "#{color_orange}\\0#{color_reset}")
+          .gsub(/\bu:\d+\b/, "#{color_cyan}\\0#{color_reset}")
+          .gsub(/\bn:\d+\b/, "#{color_green}\\0#{color_reset}")
+          .gsub(/\bd:\d+\b/, "#{color_red}\\0#{color_reset}")
+          .gsub(/\br:\d+\b/, "#{color_yellow}\\0#{color_reset}")
+          .gsub(/\bs:\d+\b/, "#{color_magenta}\\0#{color_reset}")
+      end
+
+      def color_output?
+        return false if env.key?("NO_COLOR")
+        return true if truthy?(env.fetch("DX_COLOR", "false"))
+        return true if env["DX_SHELL_WRAPPED"] == "1"
+
+        out.tty?
+      end
+
+      def usage_error(message)
+        err.puts("Usage: #{message}")
+        2
+      end
+
+      def resolve_command(raw)
+        return { command: raw, error: nil } if %w[--help -h].include?(raw)
+        commands = self.class::COMMANDS
+        return { command: raw, error: nil } if commands.include?(raw)
+
+        matches = commands.select { |cmd| cmd.start_with?(raw) }
+        if matches.empty?
+          err.puts("dx: unknown command '#{raw}'")
+          cmd_help
+          return { command: nil, error: :unknown }
+        end
+
+        if matches.length > 1
+          err.puts("dx: ambiguous command abbreviation '#{raw}'")
+          err.puts("dx: could match: #{matches.join(', ')}")
+          return { command: nil, error: :ambiguous }
+        end
+
+        { command: matches.first, error: nil }
+      end
+    end
+  end
+end

data/lib/dev_context/config.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+
+module DevContext
+  class Config
+    DEFAULT_PATH = File.expand_path("~/.dxcf").freeze
+    DEFAULTS = {
+      "version" => 1,
+      "contexts" => {},
+      "active_stack" => [],
+      "repos" => {},
+      "clone_roots" => []
+    }.freeze
+
+    attr_reader :path, :data
+
+    def initialize(path: ENV.fetch("DX_CONFIG_PATH", DEFAULT_PATH))
+      @path = path
+      @data = load_data
+    end
+
+    def initialized?
+      File.exist?(path)
+    end
+
+    def init!
+      return false if initialized?
+
+      @data = DEFAULTS.dup
+      save!
+      true
+    end
+
+    def contexts
+      data.fetch("contexts")
+    end
+
+    def repos
+      data.fetch("repos")
+    end
+
+    def active_stack
+      data.fetch("active_stack")
+    end
+
+    def add_context(name:, repo_path:, branch:)
+      timestamp = Time.now.utc.iso8601
+      context_name = normalize_name(name)
+
+      contexts[context_name] = {
+        "name" => context_name,
+        "repo_path" => File.expand_path(repo_path),
+        "branch" => branch,
+        "created_at" => contexts[context_name]&.fetch("created_at", timestamp) || timestamp,
+        "last_used_at" => timestamp
+      }
+      touch_repo!(repo_path)
+      save!
+      context_name
+    end
+
+    def get_context(name_or_path)
+      key = normalize_name(name_or_path)
+      contexts[key] || contexts.values.find { |ctx| ctx["repo_path"] == File.expand_path(name_or_path) }
+    end
+
+    def activate_context!(context_name)
+      name = normalize_name(context_name)
+      context = contexts.fetch(name)
+
+      active_stack.delete(name)
+      active_stack.unshift(name)
+      context["last_used_at"] = Time.now.utc.iso8601
+      save!
+      context
+    end
+
+    def deactivate_context!(context_name)
+      name = normalize_name(context_name)
+      removed = active_stack.delete(name)
+      save! if removed
+      !!removed
+    end
+
+    def active_contexts
+      active_stack.filter_map { |name| contexts[name] }
+    end
+
+    def normalize_name(name)
+      name.to_s.strip.downcase
+    end
+
+    private
+
+    def load_data
+      return DEFAULTS.dup unless File.exist?(path)
+
+      raw = YAML.safe_load_file(path, permitted_classes: [Time], aliases: true) || {}
+      merged = DEFAULTS.merge(raw)
+      merged["contexts"] ||= {}
+      merged["active_stack"] ||= []
+      merged["repos"] ||= {}
+      merged["clone_roots"] ||= []
+      merged
+    rescue Psych::SyntaxError => e
+      raise Error, "Invalid ~/.dxcf YAML: #{e.message}"
+    end
+
+    def save!
+      File.write(path, YAML.dump(data))
+    end
+
+    def touch_repo!(repo_path)
+      basename = File.basename(File.expand_path(repo_path))
+      data["repos"][basename] = {
+        "path" => File.expand_path(repo_path),
+        "last_seen_at" => Time.now.utc.iso8601
+      }
+    end
+  end
+end

data/lib/dev_context/matcher.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DevContext
+  class Matcher
+    def initialize(config:)
+      @config = config
+    end
+
+    def resolve(query)
+      return nil if query.to_s.strip.empty?
+
+      normalized = config.normalize_name(query)
+
+      exact = config.contexts[normalized]
+      return exact if exact
+
+      absolute_query = File.expand_path(query)
+      path_match = config.contexts.values.find { |ctx| ctx["repo_path"] == absolute_query }
+      return path_match if path_match
+
+      fuzzy_match(normalized)
+    end
+
+    private
+
+    attr_reader :config
+
+    def fuzzy_match(normalized_query)
+      matches = config.contexts.values.filter do |ctx|
+        subsequence?(normalized_query, ctx["name"]) || subsequence?(normalized_query, File.basename(ctx["repo_path"]).downcase)
+      end
+      return nil if matches.empty?
+
+      scored = matches.sort_by { |ctx| [score(normalized_query, ctx["name"]), ctx["name"]] }
+      best = scored.first
+      # If first two scores tie exactly, consider ambiguous.
+      return nil if scored[1] && score(normalized_query, scored[1]["name"]) == score(normalized_query, best["name"])
+
+      best
+    end
+
+    def subsequence?(needle, haystack)
+      i = 0
+      haystack.each_char do |char|
+        i += 1 if i < needle.length && needle[i] == char
+      end
+      i == needle.length
+    end
+
+    def score(query, candidate)
+      distance = candidate.length - query.length
+      starts = candidate.start_with?(query) ? 0 : 1
+      [starts, distance]
+    end
+  end
+end

data/lib/dev_context/shell_emitter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module DevContext
+  class ShellEmitter
+    SCRIPT_MARKER = "# DX_SHELL_EVAL".freeze
+
+    def initialize(context:, remote_name:, auto_create_local_branch:)
+      @context = context
+      @remote_name = remote_name
+      @auto_create_local_branch = auto_create_local_branch
+    end
+
+    def activation_script
+      repo = Shellwords.escape(context.fetch("repo_path"))
+      branch = Shellwords.escape(context.fetch("branch"))
+      forced_remote = Shellwords.escape(remote_name)
+      auto_create_flag = auto_create_local_branch ? "true" : "false"
+
+      <<~SH
+        #{SCRIPT_MARKER}
+        __dx_fail() { echo "$1" 1>&2; return "${2:-1}"; }
+        cd #{repo} || __dx_fail "dx: could not cd into #{repo}" 11
+        git rev-parse --is-inside-work-tree >/dev/null 2>&1 || __dx_fail "dx: not a git repository: #{repo}" 12
+
+        if git show-ref --verify --quiet "refs/heads/#{branch}"; then
+          git checkout #{branch} >/dev/null 2>&1 || __dx_fail "dx: checkout failed for #{branch}" 13
+        elif git show-ref --verify --quiet "refs/remotes/origin/#{branch}" && [ "#{auto_create_flag}" = "true" ]; then
+          git checkout -t "origin/#{branch}" >/dev/null 2>&1 || __dx_fail "dx: could not create local tracking branch #{branch}" 14
+        else
+          __dx_fail "dx: branch '#{branch}' was not found locally; set DX_AUTO_CREATE_LOCAL_BRANCH=true and ensure origin/#{branch} exists" 15
+        fi
+
+        if [ #{forced_remote.inspect} = "USE-REPO" ]; then
+          upstream="$(git rev-parse --abbrev-ref --symbolic-full-name '@{upstream}' 2>/dev/null || true)"
+          if [ -n "$upstream" ]; then
+            remote="${upstream%%/*}"
+            upstream_branch="${upstream#*/}"
+            git pull --ff-only --autostash "$remote" "$upstream_branch" || __dx_fail "dx: pull failed for upstream $upstream (you are already in the target repo for investigation)" 16
+          else
+            remote_count="$(git remote | wc -l | tr -d ' ')"
+            if [ "$remote_count" = "1" ]; then
+              remote="$(git remote | head -n1)"
+              git pull --ff-only --autostash "$remote" #{branch} || __dx_fail "dx: pull failed from $remote/#{branch} (you are already in the target repo for investigation)" 17
+            else
+              __dx_fail "dx: no upstream is configured and remote is ambiguous; configure upstream or set DX_GIT_REMOTE_NAME" 18
+            fi
+          fi
+        else
+          git remote get-url #{forced_remote} >/dev/null 2>&1 || __dx_fail "dx: remote '#{forced_remote}' does not exist in this repo" 19
+          git pull --ff-only --autostash #{forced_remote} #{branch} || __dx_fail "dx: pull failed from #{forced_remote}/#{branch} (you are already in the target repo for investigation)" 20
+        fi
+      SH
+    end
+
+    private
+
+    attr_reader :context, :remote_name, :auto_create_local_branch
+  end
+end