devex 0.3.5

data/exe/dx

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/devex"
+
+# Extract --dx-from-dir before project discovery
+# This flag affects where we look for the project root
+argv     = ARGV.dup
+from_dir = nil
+argv.reject! do |arg|
+  if arg.start_with?("--dx-from-dir=")
+    from_dir = arg.split("=", 2).last
+    true
+  elsif arg == "--dx-from-dir" && argv.index(arg) < argv.size - 1
+    # Handle --dx-from-dir PATH (space-separated)
+    idx = argv.index(arg)
+    from_dir = argv[idx + 1]
+    begin
+      argv.delete_at(idx + 1)
+    rescue StandardError
+      nil
+    end
+    true
+  else
+    false
+  end
+end
+
+# Set dest_dir if --dx-from-dir was provided
+Devex::Dirs.dest_dir = File.expand_path(from_dir) if from_dir
+
+# Check for .dx-use-local and delegate to bundled dx if present
+# This ensures version consistency when a project pins a specific devex version
+Devex::Dirs.maybe_delegate_to_local!(config: Devex::DX_CONFIG, argv: argv)
+
+# Create CLI with dx configuration
+cli = Devex::CLI.new(config: Devex::DX_CONFIG)
+
+# Load built-in tools
+cli.load_builtins
+
+# Find project root and load project tools
+# Use from_dir if provided, otherwise search from current directory
+search_from = from_dir ? File.expand_path(from_dir) : Dir.pwd
+project_root, _marker = Devex.find_project_root(search_from)
+cli.load_project_tools(project_root) if project_root
+
+# Merge builtins (project takes precedence)
+cli.merge_builtins
+
+# Run
+exit cli.run(argv)

data/lib/devex/builtins/.index.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Devex built-in tools root configuration
+
+desc "Developer experience CLI"
+long_desc <<~DESC
+  devex provides common development tasks for Ruby projects.
+
+  Run 'dx help COMMAND' for more information on a specific command.
+DESC

data/lib/devex/builtins/debug.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Hidden from help - useful for debugging context detection issues
+# Access via: dx debug
+
+desc "Debug context detection"
+
+def run
+  ctx = Devex::Context
+
+  data = {
+    tty:         {
+      stdout:   $stdout.tty?,
+      stderr:   $stderr.tty?,
+      stdin:    $stdin.tty?,
+      terminal: ctx.terminal?
+    },
+    streams:     {
+      merged: ctx.streams_merged?,
+      piped:  ctx.piped?
+    },
+    environment: {
+      ci:               ctx.ci?,
+      env:              ctx.env,
+      agent_mode_env:   ctx.agent_mode_env?,
+      dx_agent_mode:    ENV.fetch("DX_AGENT_MODE", nil),
+      devex_agent_mode: ENV.fetch("DEVEX_AGENT_MODE", nil)
+    },
+    detection:   {
+      agent_mode:  ctx.agent_mode?,
+      interactive: ctx.interactive?,
+      color:       ctx.color?
+    },
+    call_tree:   ctx.call_tree,
+    overrides:   ctx.overrides
+  }
+
+  case output_format
+  when :json, :yaml then Devex::Output.data(data, format: output_format)
+  else
+    $stdout.print Devex.render_template("debug", data)
+  end
+end

data/lib/devex/builtins/format.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Uses prj.linter - fails fast with helpful message if not found.
+
+desc "Auto-format code"
+
+long_desc <<~DESC
+  Auto-formats code using your linter's fix mode.
+  Equivalent to `dx lint --fix`.
+
+  Supports:
+    - RuboCop (.rubocop.yml) - runs rubocop -a
+    - StandardRB (.standard.yml) - runs standardrb --fix
+DESC
+
+flag :unsafe, "-A", "--unsafe", desc: "Include unsafe corrections"
+remaining_args :files, desc: "Specific files or patterns to format"
+
+def run
+  # prj.linter fails fast if no .rubocop.yml or .standard.yml found
+  linter_config = prj.linter
+
+  case linter_config.basename.to_s
+  when ".standard.yml" then run_standardrb
+  when ".rubocop.yml"  then run_rubocop
+  end
+end
+
+def prj = @prj ||= Devex::ProjectPaths.new
+
+def run_rubocop
+  args = ["rubocop"]
+  args << (unsafe ? "-A" : "-a")
+  args += files unless files.empty?
+
+  cmd(*args, chdir: prj.root).exit_on_failure!
+end
+
+def run_standardrb
+  args = ["standardrb", "--fix"]
+  args += files unless files.empty?
+
+  cmd(*args, chdir: prj.root).exit_on_failure!
+end

data/lib/devex/builtins/gem.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Uses prj.gemspec - fails fast with helpful message if not found.
+
+desc "Gem packaging tasks"
+
+long_desc <<~DESC
+  Build and manage gem packages.
+
+  Subcommands:
+    dx gem build    - Build the gem (.gem file)
+    dx gem install  - Build and install locally
+    dx gem clean    - Remove built gem files
+DESC
+
+tool "build" do
+  desc "Build the gem"
+
+  def run
+    cmd("gem", "build", prj.gemspec.basename, chdir: prj.root).exit_on_failure!
+  end
+
+  def prj = @prj ||= Devex::ProjectPaths.new
+end
+
+tool "install" do
+  desc "Build and install gem locally"
+
+  def run
+    $stdout.puts "Building gem..."
+    cmd("gem", "build", prj.gemspec.basename, chdir: prj.root)
+      .then { install_built_gem }
+      .exit_on_failure!
+  end
+
+  def install_built_gem
+    gem_file = prj.root.glob("*.gem").max_by(&:mtime)
+    unless gem_file
+      $stderr.puts "Build succeeded but no .gem file found"
+      exit 1
+    end
+
+    $stdout.puts "Installing #{gem_file.basename}..."
+    result = cmd("gem", "install", gem_file.basename, "--local", chdir: prj.root)
+
+    if result.success?
+      gem_file.rm
+      $stdout.puts "Installed and cleaned up."
+    end
+
+    result
+  end
+
+  def prj = @prj ||= Devex::ProjectPaths.new
+end
+
+tool "clean" do
+  desc "Remove built gem files"
+
+  def run
+    gem_files = prj.root.glob("*.gem")
+    if gem_files.empty?
+      $stdout.puts "No .gem files to clean"
+    else
+      gem_files.each do |f|
+        f.rm
+        $stdout.puts "Removed #{f.basename}"
+      end
+    end
+  end
+
+  def prj = @prj ||= Devex::ProjectPaths.new
+end
+
+def run
+  cli.show_help(tool)
+end

data/lib/devex/builtins/lint.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Uses prj.linter - fails fast with helpful message if not found.
+
+desc "Run linter"
+
+long_desc <<~DESC
+  Auto-detects and runs your linter from the project root.
+
+  Supports:
+    - RuboCop (.rubocop.yml)
+    - StandardRB (.standard.yml)
+
+  Pass additional arguments after -- to forward to the linter:
+    dx lint -- --only=Style/StringLiterals
+DESC
+
+flag :fix, "-a", "--fix", desc: "Auto-fix correctable offenses"
+flag :unsafe, "-A", "--unsafe-fix", desc: "Auto-fix including unsafe corrections"
+flag :diff, "-d", "--diff", desc: "Only lint changed files (git diff)"
+remaining_args :files, desc: "Specific files or patterns to lint"
+
+def run
+  # prj.linter fails fast if no .rubocop.yml or .standard.yml found
+  linter_config = prj.linter
+
+  case linter_config.basename.to_s
+  when ".standard.yml" then run_standardrb
+  when ".rubocop.yml"  then run_rubocop
+  end
+end
+
+def prj = @prj ||= Devex::ProjectPaths.new
+
+def run_rubocop
+  args = ["rubocop"]
+  args << "-a" if fix && !unsafe
+  args << "-A" if unsafe
+  args += changed_files if diff && files.empty?
+  args += files unless files.empty?
+
+  cmd(*args, chdir: prj.root).exit_on_failure!
+end
+
+def run_standardrb
+  args = ["standardrb"]
+  args << "--fix" if fix || unsafe
+  args += changed_files if diff && files.empty?
+  args += files unless files.empty?
+
+  cmd(*args, chdir: prj.root).exit_on_failure!
+end
+
+def changed_files
+  result = capture("git", "diff", "--name-only", "--diff-filter=ACMR", "HEAD", chdir: prj.root)
+  return [] if result.failed?
+
+  result.stdout_lines
+        .select { |f| f.end_with?(".rb") }
+        .select { |f| (prj.root / f).exist? }
+end

data/lib/devex/builtins/test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Uses prj.test - fails fast with helpful message if not found.
+
+desc "Run tests"
+
+long_desc <<~DESC
+  Auto-detects and runs your test suite from the project root.
+
+  Supports:
+    - Minitest (test/ directory)
+    - RSpec (spec/ directory or .rspec file)
+
+  Pass additional arguments after -- to forward to the test runner:
+    dx test -- --seed=12345
+    dx test -- spec/models/user_spec.rb
+DESC
+
+flag :coverage, "-c", "--coverage", desc: "Run with coverage (sets COVERAGE=1)"
+flag :fail_fast, "--fail-fast", desc: "Stop on first failure"
+remaining_args :files, desc: "Specific test files or patterns"
+
+def run
+  # prj.test fails fast if no test/, spec/, or tests/ directory exists
+  test_dir = prj.test
+  env = coverage ? { "COVERAGE" => "1" } : {}
+
+  # Determine framework from directory name
+  case test_dir.basename.to_s
+  when "spec"
+    run_rspec(env)
+  when "test", "tests"
+    run_minitest(env)
+  end
+end
+
+def prj = @prj ||= Devex::ProjectPaths.new
+
+def run_minitest(env)
+  if files.empty?
+    rakefile = prj.root / "Rakefile"
+    if rakefile.exist? && rake_has_test_task?(rakefile)
+      cmd("rake", "test", env: env, chdir: prj.root).exit_on_failure!
+    else
+      test_files = prj.test.glob("**/*_test.rb")
+      if test_files.empty?
+        $stderr.puts "No test files found in #{prj.test}"
+        exit 1
+      end
+
+      relative_files = test_files.map { |f| f.relative_path_from(prj.root) }
+      cmd("ruby", "-Itest", "-Ilib", "-e",
+          relative_files.map { |f| "require './#{f}'" }.join("; "),
+          env: env, chdir: prj.root).exit_on_failure!
+    end
+  else
+    files.each do |file|
+      cmd("ruby", "-Itest", "-Ilib", file, env: env, chdir: prj.root).exit_on_failure!
+    end
+  end
+end
+
+def run_rspec(env)
+  args = ["rspec"]
+  args << "--fail-fast" if fail_fast
+  args += files unless files.empty?
+
+  cmd(*args, env: env, chdir: prj.root).exit_on_failure!
+end
+
+def rake_has_test_task?(rakefile)
+  content = rakefile.read
+  content.include?("TestTask") || content.include?("task :test") || content.include?("task 'test'")
+rescue StandardError
+  false
+end

data/lib/devex/builtins/version.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# Shared helpers - these are defined at the top level and available to all tools
+# when the file is re-evaluated in the execution context
+
+VERSION_FILE_PATTERNS = [
+  "lib/*/version.rb",
+  "VERSION",
+  "version.rb"
+].freeze
+
+VERSION_REGEX = /VERSION\s*=\s*["']([^"']+)["']/
+
+def find_version_file(root)
+  VERSION_FILE_PATTERNS.each do |pattern|
+    matches = Dir.glob(File.join(root, pattern))
+    return matches.first if matches.any?
+  end
+  nil
+end
+
+def read_version(file)
+  content = File.read(file)
+  if content =~ VERSION_REGEX
+    Regexp.last_match(1)
+  else
+    content.strip
+  end
+end
+
+def write_version(file, old_version, new_version)
+  content = File.read(file)
+  new_content = content.gsub(
+    /VERSION\s*=\s*["']#{Regexp.escape(old_version)}["']/,
+    %(VERSION = "#{new_version}")
+  )
+  File.write(file, new_content)
+end
+
+def bump_version(version, type)
+  parts = version.split(".").map(&:to_i)
+  parts = [0, 0, 0] if parts.length < 3
+
+  case type
+  when "major"
+    parts[0] += 1
+    parts[1] = 0
+    parts[2] = 0
+  when "minor"
+    parts[1] += 1
+    parts[2] = 0
+  when "patch" then parts[2] += 1
+  end
+
+  parts.join(".")
+end
+
+def version_error(message)
+  Devex::Output.error(message)
+  exit(1)
+end
+
+def version_output(data)
+  # Use output_format from ExecutionContext (handles global + tool flags + context default)
+  fmt = respond_to?(:output_format) ? output_format : :text
+
+  case fmt
+  when :json, :yaml then Devex::Output.data(data, format: fmt)
+  else
+    text = if data[:old_version] && data[:new_version]
+             "#{data[:old_version]} → #{data[:new_version]}"
+           else
+             data[:version].to_s
+           end
+    $stdout.print text, "\n"
+  end
+end
+
+# --- Main tool ---
+
+desc "Show or manage version"
+
+def run
+  # Try project root first, then fall back to effective working directory.
+  # This handles cases where a project exists but isn't yet recognized
+  # (e.g., no .git, Gemfile, or other project markers).
+  fallback_dir = Devex::Dirs.dest_dir.to_s
+  search_roots = [cli.project_root, fallback_dir].compact.uniq
+
+  version_data = nil
+  search_roots.each do |root|
+    version_file = find_version_file(root)
+    if version_file
+      version_data = { version: read_version(version_file), source: "project", file: version_file }
+      break
+    end
+  end
+
+  version_data ||= { version: Devex::VERSION, source: "devex" }
+
+  version_output(version_data)
+end
+
+# --- Subtools ---
+
+tool "bump" do
+  desc "Bump version (major, minor, or patch)"
+  long_desc <<~DESC
+    Bump the project version following semantic versioning.
+
+    MAJOR version for incompatible API changes
+    MINOR version for backwards-compatible new functionality
+    PATCH version for backwards-compatible bug fixes
+  DESC
+
+  required_arg :type, desc: "Version component: major, minor, or patch"
+
+  def run
+    version_error("Invalid version type '#{type}'. Use: major, minor, or patch") unless %w[major minor patch].include?(type)
+
+    version_error("Not in a project directory") unless cli.project_root
+
+    version_file = find_version_file(cli.project_root)
+    version_error("Could not find version file") unless version_file
+
+    old_version = read_version(version_file)
+    new_version = bump_version(old_version, type)
+    write_version(version_file, old_version, new_version)
+
+    version_output(
+      { old_version: old_version, new_version: new_version, type: type, file: version_file }
+    )
+  end
+end
+
+tool "set" do
+  desc "Set version to a specific value"
+
+  required_arg :version, desc: "Version string (e.g., 1.0.0)"
+
+  def run
+    version_error("Invalid version format '#{version}'. Use semantic versioning: MAJOR.MINOR.PATCH") unless version.match?(/^\d+\.\d+\.\d+/)
+
+    version_error("Not in a project directory") unless cli.project_root
+
+    version_file = find_version_file(cli.project_root)
+    version_error("Could not find version file") unless version_file
+
+    old_version = read_version(version_file)
+    write_version(version_file, old_version, version)
+
+    version_output(
+      { old_version: old_version, new_version: version, file: version_file }
+    )
+  end
+end