dev_context 1.0.0

data/lib/dev_context/commands/context_lifecycle.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module ContextLifecycle
+      def cmd_add
+        args = argv.dup
+        opts = parse_common_flags!(args, allow_context: true, allow_norun: true)
+        return usage_error("dx add PATH|URL ...") if args.empty?
+        if opts[:context] && args.length != 1
+          return usage_error("dx add -c NAME PATH|URL")
+        end
+
+        exit_code = 0
+        args.each do |target|
+          code = add_single_target(target, explicit_context: opts[:context], opts: opts)
+          exit_code = code unless code.zero?
+        end
+
+        exit_code
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx add [-c NAME] [-n] [-v] PATH|URL ...")
+      end
+
+      def cmd_clone
+        args = argv.dup
+        opts = parse_common_flags!(args, allow_context: true, allow_norun: true)
+        url = args.shift
+        explicit_path = args.shift
+        return usage_error("dx clone URL [PATH]") if blank?(url)
+        return usage_error("dx clone URL [PATH]") unless url?(url)
+
+        clone_and_register!(url, explicit_path: explicit_path, explicit_name: opts[:context], opts: opts)
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx clone [-c NAME] [-n] [-v] URL [PATH]")
+      end
+
+      def cmd_create
+        args = argv.dup
+        opts = parse_common_flags!(args, allow_context: true, allow_norun: true)
+        name = args.shift
+        name = opts[:context] if blank?(name)
+        return usage_error("dx create NAME [PATH] [BRANCH]") if blank?(name)
+
+        repo_path = args.shift || pwd
+        branch = args.shift || current_branch(repo_path) || "main"
+        if opts[:norun]
+          out.puts("Would create context #{config.normalize_name(name)} -> #{File.expand_path(repo_path)} @ #{branch}")
+          return 0
+        end
+
+        context_name = config.add_context(name: name, repo_path: repo_path, branch: branch)
+        out.puts("Created context #{context_name} -> #{File.expand_path(repo_path)} @ #{branch}")
+        0
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx create [-c NAME] [-n] [-v] NAME [PATH] [BRANCH]")
+      end
+
+      def cmd_activate
+        target = argv.shift
+        return usage_error("dx activate CONTEXT|PATH|URL or dx cd CONTEXT|PATH|URL") 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
+    end
+  end
+end

data/lib/dev_context/commands/find.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Find
+      def cmd_find
+        args = argv.dup
+        opts = { stashes: false, branches: false, paths: false, all: false }
+        parser = OptionParser.new
+        parser.on("--stashes", "Search stash entry titles") { opts[:stashes] = true }
+        parser.on("--branches", "Search current branch names") { opts[:branches] = true }
+        parser.on("--paths", "Search repo paths") { opts[:paths] = true }
+        parser.on("--all", "Show likely-forgotten work (stashes + dirty repos + detached HEAD)") { opts[:all] = true }
+        parser.parse!(args)
+
+        pattern = args.shift
+        return usage_error("dx find [--stashes|--branches|--paths] <pattern>\n       dx find --all") unless args.empty?
+        return usage_error("dx find [--stashes|--branches|--paths] <pattern>\n       dx find --all") if opts[:all] && pattern
+        return usage_error("dx find [--stashes|--branches|--paths] <pattern>\n       dx find --all") if !opts[:all] && blank?(pattern)
+
+        scopes = find_scopes(opts)
+        rows = opts[:all] ? find_all_rows(scopes) : find_pattern_rows(pattern, scopes)
+        if rows.empty?
+          out.puts(opts[:all] ? "No likely-forgotten work found" : "No matches")
+          return 0
+        end
+
+        render_find_table(rows)
+        0
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx find [--stashes|--branches|--paths] <pattern>\n       dx find --all")
+      end
+
+      private
+
+      def find_scopes(opts)
+        selected = []
+        selected << :stashes if opts[:stashes]
+        selected << :branches if opts[:branches]
+        selected << :paths if opts[:paths]
+        selected.empty? ? %i[stashes branches paths] : selected
+      end
+
+      def find_pattern_rows(pattern, scopes)
+        rows = []
+
+        if scopes.include?(:paths)
+          known_repo_rows.each do |repo|
+            next unless pattern_match?(repo[:path], pattern)
+
+            rows << { type: "path", path: repo[:path], branch: repo[:branch], detail: repo[:path] }
+          end
+        end
+
+        if scopes.include?(:branches)
+          known_repo_rows.each do |repo|
+            next unless pattern_match?(repo[:branch], pattern)
+
+            rows << { type: "branch", path: repo[:path], branch: repo[:branch], detail: repo[:branch] }
+          end
+        end
+
+        if scopes.include?(:stashes)
+          known_repo_stash_rows.each do |repo|
+            repo[:entries].each do |entry|
+              next unless pattern_match?(entry, pattern)
+
+              rows << { type: "stash", path: repo[:path], branch: repo[:branch], detail: entry }
+            end
+          end
+        end
+
+        dedupe_and_sort_find_rows(rows)
+      end
+
+      def find_all_rows(scopes)
+        rows = []
+        known = known_repo_rows
+
+        if scopes.include?(:paths)
+          known.each do |repo|
+            status = ::DevContext::Status.new(repo_path: repo[:path]).one_line
+            rows << { type: "dirty", path: repo[:path], branch: repo[:branch], detail: compact_status(status) } unless status.start_with?("Up to date")
+          end
+        end
+
+        if scopes.include?(:branches)
+          known.each do |repo|
+            rows << { type: "detached", path: repo[:path], branch: "HEAD", detail: "detached HEAD" } if repo[:branch] == "HEAD"
+          end
+        end
+
+        if scopes.include?(:stashes)
+          known_repo_stash_rows.each do |repo|
+            rows << { type: "stash", path: repo[:path], branch: repo[:branch], detail: "s:#{repo[:count]}" }
+          end
+        end
+
+        dedupe_and_sort_find_rows(rows)
+      end
+
+      def dedupe_and_sort_find_rows(rows)
+        rows
+          .uniq { |r| [r[:type], r[:path], r[:branch], r[:detail]] }
+          .sort_by { |r| [r[:type], r[:path], r[:detail]] }
+      end
+
+      def render_find_table(rows)
+        display_rows = rows.map { |row| row.merge(path: display_path(row[:path])) }
+        type_w = [display_rows.map { |r| r[:type].length }.max || 0, "Type".length].max
+        path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Path".length].max
+        branch_w = [display_rows.map { |r| r[:branch].length }.max || 0, "Branch".length].max
+
+        out.puts(format("%-#{type_w}s  %-#{path_w}s  %-#{branch_w}s  %s", "Type", "Path", "Branch", "Match"))
+        out.puts(format("%-#{type_w}s  %-#{path_w}s  %-#{branch_w}s  %s", "-" * type_w, "-" * path_w, "-" * branch_w, "-" * 5))
+        display_rows.each do |row|
+          out.puts(format("%-#{type_w}s  %-#{path_w}s  %-#{branch_w}s  %s", row[:type], row[:path], row[:branch], row[:detail]))
+        end
+      end
+    end
+  end
+end

data/lib/dev_context/commands/git_ops.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module GitOps
+      def cmd_active
+        active = config.active_contexts
+        if active.empty?
+          out.puts("No active contexts")
+          return 0
+        end
+
+        active.each do |ctx|
+          status = Status.new(repo_path: ctx.fetch("repo_path")).one_line
+          out.puts("#{ctx.fetch("name")}  #{ctx.fetch("repo_path")}  #{ctx.fetch("branch")}  #{status}")
+        end
+        0
+      end
+
+      def cmd_deactivate
+        target = argv.shift
+        return usage_error("dx deactivate CONTEXT") if blank?(target)
+
+        context = matcher.resolve(target)
+        return not_found(target) unless context
+
+        config.deactivate_context!(context.fetch("name"))
+        out.puts("Deactivated #{context.fetch("name")}")
+        0
+      end
+
+      def cmd_pop
+        target = argv.shift
+
+        if target
+          context = matcher.resolve(target)
+          return not_found(target) unless context
+
+          removed = config.deactivate_context!(context.fetch("name"))
+          return not_found(target) unless removed
+
+          out.puts("Popped #{context.fetch('name')}")
+        else
+          top_name = config.active_stack.first
+          if top_name.nil?
+            out.puts("No active contexts")
+            return 0
+          end
+
+          context = config.contexts.fetch(top_name)
+          config.deactivate_context!(top_name)
+          out.puts("Popped #{context.fetch('name')}")
+        end
+
+        new_top = config.active_contexts.first
+        return 0 unless new_top
+
+        out.puts("cd #{Shellwords.escape(new_top.fetch('repo_path'))}")
+        0
+      end
+
+      def cmd_diff
+        target = argv.shift
+        contexts = target ? [matcher.resolve(target)].compact : config.active_contexts
+        return not_found(target) if target && contexts.empty?
+        if contexts.empty?
+          out.puts("No active contexts")
+          return 0
+        end
+
+        contexts.each do |ctx|
+          path = ctx.fetch("repo_path")
+          out.puts("# #{ctx.fetch('name')} (#{path})")
+          out.print(`git -C "#{path}" diff`)
+        end
+        0
+      end
+
+      def cmd_branches
+        target = argv.shift
+        return usage_error("dx branches|br [CONTEXT|PATTERN]") unless argv.empty?
+
+        if target
+          context = matcher.resolve(target)
+          if context
+            contexts = [context]
+            contexts.each do |ctx|
+              path = ctx.fetch("repo_path")
+              out.puts("# #{ctx.fetch('name')} (#{path})")
+              out.print(`git -C "#{path}" branch --list`)
+            end
+            return 0
+          end
+
+          rows = known_repo_rows.filter_map do |repo|
+            next unless pattern_match?(repo[:branch], target)
+
+            repo
+          end.sort_by { |row| [row[:branch], row[:path]] }
+
+          if rows.empty?
+            out.puts("No matching branches")
+            return 0
+          end
+
+          display_rows = rows.map { |r| r.merge(path: display_path(r[:path])) }
+          path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Repo".length].max
+          branch_w = [display_rows.map { |r| r[:branch].length }.max || 0, "Branch".length].max
+          out.puts(format("%-#{path_w}s  %-#{branch_w}s", "Repo", "Branch"))
+          out.puts(format("%-#{path_w}s  %-#{branch_w}s", "-" * path_w, "-" * branch_w))
+          display_rows.each { |row| out.puts(format("%-#{path_w}s  %-#{branch_w}s", row[:path], row[:branch])) }
+          return 0
+        end
+
+        contexts = config.active_contexts
+        if contexts.empty?
+          out.puts("No active contexts")
+          return 0
+        end
+
+        contexts.each do |ctx|
+          path = ctx.fetch("repo_path")
+          out.puts("# #{ctx.fetch('name')} (#{path})")
+          out.print(`git -C "#{path}" branch --list`)
+        end
+        0
+      end
+
+      def cmd_checkout
+        args = argv.dup
+        create_flag = false
+        if args.first == "-b"
+          create_flag = true
+          args.shift
+        end
+        feature = args.shift
+        target = args.shift
+        return usage_error("dx co|checkout [-b] FEATURE [CONTEXT]") if blank?(feature)
+
+        context = if target
+                    matcher.resolve(target)
+                  else
+                    config.active_contexts.first
+                  end
+        return not_found(target || "active context") unless context
+
+        cmd = create_flag ? %(git -C "#{context.fetch('repo_path')}" checkout -b #{Shellwords.escape(feature)} 2>&1) :
+                            %(git -C "#{context.fetch('repo_path')}" checkout #{Shellwords.escape(feature)} 2>&1)
+        output = `#{cmd}`
+        unless $?.success?
+          err.puts(output)
+          return 28
+        end
+
+        context_name = context.fetch("name")
+        config.contexts[context_name]["branch"] = feature
+        config.send(:save!)
+        out.puts("Checked out #{feature} in #{context_name}")
+        0
+      end
+    end
+  end
+end

data/lib/dev_context/commands/help.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Help
+      def cmd_help(topic = nil)
+        topic ||= argv.first
+        if topic
+          resolution = resolve_command(topic)
+          normalized = resolution.is_a?(Hash) ? resolution[:command] : resolution
+          return 1 if normalized.nil?
+
+          return cmd_help_topic(normalized)
+        end
+
+        out.puts <<~HELP
+          dx - developer context manager
+
+          Commands:
+            dx active
+            dx add PATH|URL ...
+            dx activate CONTEXT|PATH|URL
+            dx branches|br [CONTEXT|PATTERN]
+            dx cd CONTEXT|PATH|URL
+            dx checkout|co [-b] FEATURE [CONTEXT]
+            dx clone URL [PATH]
+            dx create NAME [PATH] [BRANCH]
+            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 repos [PATTERN]
+            dx remove CONTEXT|PATH
+            dx stashes [--list] [PATTERN]
+            dx status|wip
+        HELP
+        0
+      end
+
+      def cmd_help_topic(command)
+        text = case command
+               when "status", "wip"
+                 "Usage: dx status [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]\n       dx wip [--all] [--dirty] [-b BRANCHPATTERN] [-p PATHPATTERN]\n\nShow branch and git status for active contexts. Use --all for all known repos, --dirty to filter non-clean repos, and -b/-p to filter by branch/path."
+               when "repos"
+                 "Usage: dx repos [-b BRANCHPATTERN] [-p PATHPATTERN] [PATTERN]\n\nList all known repos without git status details. PATTERN is shorthand for path filtering."
+               when "stashes"
+                 "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 "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"
+                 "Usage: dx #{command} CONTEXT|PATH|URL"
+               when "popd"
+                 "Usage: dx popd [CONTEXT]"
+               when "remove"
+                 "Usage: dx remove CONTEXT|PATH"
+               when "diff"
+                 "Usage: dx diff [CONTEXT]"
+               when "branches", "br"
+                 "Usage: dx branches|br [CONTEXT|PATTERN]\n\nWith a context, list git branches in that repo. With PATTERN, find repos whose current branch matches."
+               when "checkout", "co"
+                 "Usage: dx checkout|co [-b] FEATURE [CONTEXT]"
+               else
+                 "Usage: dx #{command}"
+               end
+        out.puts(text)
+        0
+      end
+    end
+  end
+end

data/lib/dev_context/commands/init.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Init
+      def cmd_init
+        created = config.init!
+        shell_status = ShellSetup.new.install!
+
+        out.puts(created ? "Initialized ~/.dxcf" : "~/.dxcf already exists")
+        shell_message = case shell_status
+                        when :created then "Created ~/.dx.sh"
+                        when :updated then "Updated ~/.dx.sh"
+                        else "~/.dx.sh already exists"
+                        end
+        out.puts(shell_message)
+        out.puts('Add `source ~/.dx.sh` to ~/.zshrc or ~/.bashrc')
+        0
+      end
+    end
+  end
+end

data/lib/dev_context/commands/remove.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Remove
+      def cmd_remove
+        target = argv.shift
+        return usage_error("dx remove CONTEXT|PATH") if blank?(target)
+
+        context = matcher.resolve(target)
+        return not_found(target) unless context
+
+        name = context.fetch("name")
+        config.active_stack.delete(name)
+        config.contexts.delete(name)
+        config.send(:save!)
+        out.puts("Removed #{name}")
+        0
+      end
+    end
+  end
+end

data/lib/dev_context/commands/repos.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Repos
+      def cmd_repos
+        args = argv.dup
+        branch_pattern = nil
+        path_pattern = nil
+        parser = OptionParser.new
+        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)
+        shortcut_pattern = args.shift
+        return usage_error("dx repos [-b BRANCHPATTERN] [-p PATHPATTERN] [PATTERN]") unless args.empty?
+        path_pattern ||= shortcut_pattern
+
+        rows = known_repo_rows
+
+        rows = rows.select { |row| pattern_match?(row[:branch], branch_pattern) }
+        rows = rows.select { |row| pattern_match?(row[:path], path_pattern) }
+        if rows.empty?
+          out.puts("No known repos")
+          return 0
+        end
+
+        display_rows = rows.map { |r| r.merge(path: display_path(r[:path])) }.sort_by { |r| r[:path] }
+        path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Repo".length].max
+        branch_w = [display_rows.map { |r| r[:branch].length }.max || 0, "Branch".length].max
+
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s", "Repo", "Branch"))
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s", "-" * path_w, "-" * branch_w))
+        display_rows.each { |row| out.puts(format("%-#{path_w}s  %-#{branch_w}s", row[:path], row[:branch])) }
+        0
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx repos [-b BRANCHPATTERN] [-p PATHPATTERN] [PATTERN]")
+      end
+
+    end
+  end
+end

data/lib/dev_context/commands/search_helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module SearchHelpers
+      private
+
+      def 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)
+
+          {
+            path: expanded,
+            branch: current_branch(expanded) || "-"
+          }
+        end
+      end
+
+      def known_repo_stash_rows(pattern: nil)
+        known_repo_rows.filter_map do |repo|
+          entries = stash_entries(repo[:path])
+          entries = entries.select { |entry| pattern_match?(entry, pattern) } if pattern
+          next if entries.empty?
+
+          repo.merge(
+            count: entries.length,
+            entries: entries
+          )
+        end.sort_by { |row| [-row[:count], row[:path]] }
+      end
+
+      def stash_entries(repo_path)
+        output = `git -C "#{repo_path}" stash list 2>/dev/null`
+        return [] unless $?.success?
+
+        output.lines.map(&:chomp).reject(&:empty?)
+      end
+
+      def pattern_match?(value, pattern)
+        return true if pattern.nil? || pattern.empty?
+
+        val = value.to_s
+        pat = pattern.to_s
+        if pat.match?(/[*?\[]/)
+          File.fnmatch?(pat, val, File::FNM_CASEFOLD)
+        else
+          val.downcase.include?(pat.downcase)
+        end
+      end
+    end
+  end
+end

data/lib/dev_context/commands/stashes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DevContext
+  module Commands
+    module Stashes
+      def cmd_stashes
+        args = argv.dup
+        show_list = false
+        parser = OptionParser.new
+        parser.on("-l", "--list", "Show stash entry titles per repo") { show_list = true }
+        parser.parse!(args)
+        pattern = args.shift
+        return usage_error("dx stashes [--list] [PATTERN]") unless args.empty?
+
+        rows = known_repo_stash_rows(pattern: pattern)
+        if rows.empty?
+          out.puts("No repos with stashes")
+          return 0
+        end
+
+        render_stash_table(rows)
+        return 0 unless show_list
+
+        out.puts
+        rows.each do |row|
+          out.puts("#{display_path(row[:path])}:")
+          row[:entries].each { |entry| out.puts("  - #{entry}") }
+        end
+        0
+      rescue OptionParser::InvalidOption => e
+        err.puts("dx: #{e.message}")
+        usage_error("dx stashes [--list] [PATTERN]")
+      end
+
+      private
+
+      def render_stash_table(rows)
+        display_rows = rows.map { |row| row.merge(path: display_path(row[:path])) }
+        path_w = [display_rows.map { |r| r[:path].length }.max || 0, "Path".length].max
+        branch_w = [display_rows.map { |r| r[:branch].length }.max || 0, "Branch".length].max
+
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s  %s", "Path", "Branch", "Stashes"))
+        out.puts(format("%-#{path_w}s  %-#{branch_w}s  %s", "-" * path_w, "-" * branch_w, "-" * 7))
+        display_rows.each do |row|
+          out.puts(format("%-#{path_w}s  %-#{branch_w}s  s:%d", row[:path], row[:branch], row[:count]))
+        end
+      end
+    end
+  end
+end