RubyGems - ruby_workspace_manager - Versions diffs - 0.3.0 → 0.5.0 - Mend

ruby_workspace_manager 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbe69d99300fafa6359944aa4a1cb16a3ed9cbb0e1e544b3a428a4e04af4dc66
-  data.tar.gz: 114e54d2ac5872ae866ecf0503b8ebdeb9c72b0db892a564e0b3889b4ff1e0fd
+  metadata.gz: dab8a0ae74fbf4b09e06f997a9b88d3d80e535b16c290eca3d7429fc67c1e3cd
+  data.tar.gz: dec2cd0382c7613fa43f62294a7ed32254355046ce33e903d023bde7cc6a2cc9
 SHA512:
-  metadata.gz: bad333bc09182d824ef4c5b4e50fc290a7922e81a8e616a991d54cf994cca8340038fc5bb4b2dfa1612292ac7fc3f6008089ea6ff7a95b702ef65c0335ee97b4
-  data.tar.gz: bdfb899d956de2f9aa4d694d83b74cd79cb9936c0f38cfa1f64c78931846436be644510e0fce9dcfb8774af61b74d5cc24e09769aa0b2547c6a9ffba45d1dc95
+  metadata.gz: 228e51efcfe4f4ec0a230eb1fd2d7c56f67464d961d6427c7df81f2da3648573920bb84b24b73d9874e461ab34ba35d1f3c2de6e8bdc442139509887ee5b50f9
+  data.tar.gz: 391aa7d70d6c236a99a79c02832ffc3dc22b5d897c1c6b83b3ab8d22efae9be9214c673015a69a8273ff743df85053c0b721e8fd5b607bf3424a485ebd0716bb

data/README.md CHANGED Viewed

@@ -18,12 +18,15 @@ RWM manages Ruby monorepos with multiple apps and libraries. It builds a depende
 | `rwm new <app\|lib> <name>` | Scaffold a new package. |
 | `rwm graph` | Rebuild the dependency graph. `--dot` / `--mermaid` for visualization. |
 | `rwm run <task> [pkg]` | Run a Rake task across packages. Packages without the task are skipped. |
-| `rwm test` | Shortcut for `rwm run test`. Also: `rwm spec`, `rwm build`. |
+| `rwm <task> [pkg]` | Any unknown command is a task shortcut: `rwm test` = `rwm run test`. |
 | `rwm run <task> --affected` | Run only on packages affected by current changes. |
 | `rwm check` | Validate conventions. |
 | `rwm list` | List all packages. |
 | `rwm info <name>` | Show package details. |
 | `rwm affected` | Show affected packages. |
+| `rwm cache clean [pkg]` | Clear cached task results. |
+Shell completions for Bash and Zsh are included — see [GUIDE.md](GUIDE.md) for setup instructions.
 See [GUIDE.md](GUIDE.md) for full usage documentation — dependencies, caching, affected detection, git hooks, design decisions, and more.

data/completions/rwm.bash ADDED Viewed

@@ -0,0 +1,169 @@
+# Bash completion for rwm (Ruby Workspace Manager)
+# Source this file in your .bashrc or .bash_profile:
+#   source "$(gem contents ruby_workspace_manager | grep rwm.bash)"
+_rwm_find_workspace_root() {
+  local dir="$PWD"
+  while [[ "$dir" != "/" ]]; do
+    if [[ -d "$dir/.git" ]]; then
+      echo "$dir"
+      return
+    fi
+    dir="$(dirname "$dir")"
+  done
+}
+_rwm_packages() {
+  local root
+  root="$(_rwm_find_workspace_root)"
+  [[ -z "$root" ]] && return
+  local dir
+  for dir in "$root"/libs/*/ "$root"/apps/*/; do
+    [[ -d "$dir" && -f "$dir/Gemfile" ]] && echo "${dir%/}" | xargs basename
+  done
+}
+_rwm() {
+  local cur prev words cword
+  _init_completion || return
+  local commands="init bootstrap new info graph check list run affected cache help version"
+  local global_flags="--verbose --help --version"
+  # Find the command (first non-flag argument after rwm)
+  local cmd="" cmd_index=0
+  local i
+  for ((i = 1; i < cword; i++)); do
+    case "${words[i]}" in
+      --verbose) ;;
+      -*) ;;
+      *)
+        cmd="${words[i]}"
+        cmd_index=$i
+        break
+        ;;
+    esac
+  done
+  # No command yet — complete commands and global flags
+  if [[ -z "$cmd" ]]; then
+    COMPREPLY=($(compgen -W "$commands $global_flags" -- "$cur"))
+    return
+  fi
+  # Per-command completions
+  case "$cmd" in
+    init)
+      COMPREPLY=($(compgen -W "--vscode" -- "$cur"))
+      ;;
+    bootstrap | check | list | help | version)
+      ;;
+    new)
+      local pos=$((cword - cmd_index))
+      if [[ $pos -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "app lib" -- "$cur"))
+      fi
+      ;;
+    info)
+      local pos=$((cword - cmd_index))
+      if [[ $pos -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "$(_rwm_packages)" -- "$cur"))
+      fi
+      ;;
+    graph)
+      COMPREPLY=($(compgen -W "--dot --mermaid" -- "$cur"))
+      ;;
+    affected)
+      case "$prev" in
+        --base) ;;
+        *)
+          COMPREPLY=($(compgen -W "--base --committed" -- "$cur"))
+          ;;
+      esac
+      ;;
+    cache)
+      local pos=$((cword - cmd_index))
+      if [[ $pos -eq 1 ]]; then
+        COMPREPLY=($(compgen -W "clean" -- "$cur"))
+      elif [[ $pos -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "$(_rwm_packages)" -- "$cur"))
+      fi
+      ;;
+    run)
+      local run_flags="--affected --committed --base --dry-run --no-cache --buffered --concurrency"
+      case "$prev" in
+        --base | --concurrency)
+          # These flags expect a value; don't complete
+          ;;
+        *)
+          # Count positional args (skip flags and flag values)
+          local positionals=0
+          local skip_next=false
+          for ((i = cmd_index + 1; i < cword; i++)); do
+            if $skip_next; then
+              skip_next=false
+              continue
+            fi
+            case "${words[i]}" in
+              --base | --concurrency)
+                skip_next=true
+                ;;
+              -*)
+                ;;
+              *)
+                ((positionals++))
+                ;;
+            esac
+          done
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "$run_flags" -- "$cur"))
+          elif [[ $positionals -eq 0 ]]; then
+            # First positional: task name (no completion — user-defined)
+            :
+          elif [[ $positionals -eq 1 ]]; then
+            # Second positional: package name
+            COMPREPLY=($(compgen -W "$(_rwm_packages)" -- "$cur"))
+          fi
+          ;;
+      esac
+      ;;
+    *)
+      # Any unrecognized command is a task shortcut — offer run flags and packages
+      local run_flags="--affected --committed --base --dry-run --no-cache --buffered --concurrency"
+      case "$prev" in
+        --base | --concurrency)
+          ;;
+        *)
+          local positionals=0
+          local skip_next=false
+          for ((i = cmd_index + 1; i < cword; i++)); do
+            if $skip_next; then
+              skip_next=false
+              continue
+            fi
+            case "${words[i]}" in
+              --base | --concurrency)
+                skip_next=true
+                ;;
+              -*)
+                ;;
+              *)
+                ((positionals++))
+                ;;
+            esac
+          done
+          if [[ "$cur" == -* ]]; then
+            COMPREPLY=($(compgen -W "$run_flags" -- "$cur"))
+          elif [[ $positionals -eq 0 ]]; then
+            COMPREPLY=($(compgen -W "$(_rwm_packages)" -- "$cur"))
+          fi
+          ;;
+      esac
+      ;;
+  esac
+}
+complete -F _rwm rwm

data/completions/rwm.zsh ADDED Viewed

@@ -0,0 +1,125 @@
+#compdef rwm
+# Zsh completion for rwm (Ruby Workspace Manager)
+# Add the completions directory to your fpath in .zshrc:
+#   fpath=($(gem contents ruby_workspace_manager | grep completions/rwm.zsh | xargs dirname) $fpath)
+#   autoload -Uz compinit && compinit
+_rwm_find_workspace_root() {
+  local dir="${PWD}"
+  while [[ "$dir" != "/" ]]; do
+    if [[ -d "$dir/.git" ]]; then
+      echo "$dir"
+      return
+    fi
+    dir="${dir:h}"
+  done
+}
+_rwm_complete_packages() {
+  local root
+  root="$(_rwm_find_workspace_root)"
+  [[ -z "$root" ]] && return
+  local -a packages
+  local dir
+  for dir in "$root"/libs/*(N/) "$root"/apps/*(N/); do
+    [[ -f "$dir/Gemfile" ]] && packages+=("${dir:t}")
+  done
+  _describe 'package' packages
+}
+_rwm() {
+  local -a commands=(
+    'init:Initialize a new rwm workspace'
+    'bootstrap:Install deps and run bootstrap tasks in all packages'
+    'new:Scaffold a new app or lib'
+    'info:Show details about a package'
+    'graph:Build and save the dependency graph'
+    'check:Validate dependency graph and conventions'
+    'list:List all packages in the workspace'
+    'run:Run a rake task across all or one package'
+    'affected:Show packages affected by current changes'
+    'cache:Manage task cache'
+    'help:Show help'
+    'version:Show version'
+  )
+  local -a global_flags=(
+    '--verbose[Enable debug logging]'
+    '--help[Show help]'
+    '--version[Show version]'
+  )
+  local -a run_flags=(
+    '--affected[Only run on affected packages]'
+    '--committed[Only consider committed changes]'
+    '--base[Compare against REF instead of auto-detected base]:ref'
+    '--dry-run[Show what would run without executing]'
+    '--no-cache[Bypass task-level caching]'
+    '--buffered[Buffer output per-package and print on completion]'
+    '--concurrency[Max parallel workers]:number'
+  )
+  # If we haven't completed the first argument yet, offer commands
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+  local cmd="${words[2]}"
+  case "$cmd" in
+    init)
+      _arguments -s \
+        '--vscode[Generate VSCode .code-workspace file]' \
+        $global_flags
+      ;;
+    bootstrap | check | list | help | version)
+      ;;
+    new)
+      local -a types=('app:Application package' 'lib:Library package')
+      case $CURRENT in
+        3) _describe 'type' types ;;
+        4) _message 'package name' ;;
+      esac
+      ;;
+    info)
+      if (( CURRENT == 3 )); then
+        _rwm_complete_packages
+      fi
+      ;;
+    graph)
+      _arguments -s \
+        '--dot[Output in Graphviz DOT format]' \
+        '--mermaid[Output in Mermaid format]' \
+        $global_flags
+      ;;
+    affected)
+      _arguments -s \
+        '--base[Compare against REF instead of auto-detected base]:ref' \
+        '--committed[Only consider committed changes]' \
+        $global_flags
+      ;;
+    cache)
+      case $CURRENT in
+        3) local -a subcmds=('clean:Clear cached task results')
+           _describe 'subcommand' subcmds ;;
+        4) _rwm_complete_packages ;;
+      esac
+      ;;
+    run)
+      _arguments -s \
+        $run_flags \
+        '1:task' \
+        '2:package:_rwm_complete_packages'
+      ;;
+    *)
+      # Any unrecognized command is a task shortcut — offer run flags and packages
+      _arguments -s \
+        $run_flags \
+        '1:package:_rwm_complete_packages'
+      ;;
+  esac
+}
+_rwm "$@"

data/lib/rwm/affected_detector.rb CHANGED Viewed

@@ -6,11 +6,11 @@ module Rwm
   class AffectedDetector
     attr_reader :workspace, :graph, :base_branch
-    def initialize(workspace, graph, committed_only: false)
+    def initialize(workspace, graph, committed_only: false, base_branch: nil)
       @workspace = workspace
       @graph = graph
       @committed_only = committed_only
-      @base_branch = detect_base_branch
+      @base_branch = base_branch || detect_base_branch
     end
     # Returns packages directly changed + their transitive dependents
@@ -68,20 +68,25 @@ module Rwm
       files = Set.new
       # 1. Committed changes: base branch vs HEAD
+      Rwm.debug("affected: git diff --name-only #{base_branch}...HEAD")
       committed, _, status = Open3.capture3("git", "-C", workspace.root, "diff", "--name-only", "#{base_branch}...HEAD")
       committed.lines.each { |l| files << l.chomp } if status.success?
       unless @committed_only
         # 2. Staged changes (not yet committed)
+        Rwm.debug("affected: git diff --name-only --cached")
         staged, _, status = Open3.capture3("git", "-C", workspace.root, "diff", "--name-only", "--cached")
         staged.lines.each { |l| files << l.chomp } if status.success?
         # 3. Unstaged working directory changes
+        Rwm.debug("affected: git diff --name-only")
         unstaged, _, status = Open3.capture3("git", "-C", workspace.root, "diff", "--name-only")
         unstaged.lines.each { |l| files << l.chomp } if status.success?
       end
-      files.reject(&:empty?).to_a
+      result = files.reject(&:empty?).to_a
+      Rwm.debug("affected: #{result.size} changed file(s) detected")
+      result
     end
     def map_files_to_packages(files)

data/lib/rwm/cli.rb CHANGED Viewed

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
-require "optparse"
 module Rwm
   class CLI
     COMMANDS = {
@@ -13,12 +11,10 @@ module Rwm
       "check"     => "Commands::Check",
       "list"      => "Commands::List",
       "run"       => "Commands::Run",
-      "affected"  => "Commands::Affected"
+      "affected"  => "Commands::Affected",
+      "cache"     => "Commands::Cache"
     }.freeze
-    # Shortcuts that expand to `run <task>`
-    TASK_SHORTCUTS = %w[test spec build].freeze
     def self.run(argv)
       new(argv).run
     end
@@ -28,6 +24,8 @@ module Rwm
     end
     def run
+      parse_global_flags
       command_name = @argv.shift
       if command_name.nil? || %w[-h --help help].include?(command_name)
@@ -42,21 +40,15 @@ module Rwm
       check_required_tools
-      # Expand task shortcuts: `rwm test` → `rwm run test`
-      if TASK_SHORTCUTS.include?(command_name)
+      # Unknown commands are treated as task names: `rwm test` → `rwm run test`
+      unless COMMANDS.key?(command_name)
         @argv.unshift(command_name)
         command_name = "run"
       end
-      const_name = COMMANDS[command_name]
-      unless const_name
-        $stderr.puts "Unknown command: #{command_name}"
-        $stderr.puts "Run `rwm help` for available commands."
-        return 1
-      end
       # Autoload the command
       require "rwm/commands/#{command_name}"
+      const_name = COMMANDS[command_name]
       command_class = const_name.split("::").reduce(Rwm) { |mod, name| mod.const_get(name) }
       command_class.new(@argv).run
     rescue Rwm::Error => e
@@ -66,11 +58,17 @@ module Rwm
     private
+    def parse_global_flags
+      Rwm.verbose = true if ENV["RWM_DEBUG"] == "1"
+      if @argv.delete("--verbose")
+        Rwm.verbose = true
+      end
+    end
     def check_required_tools
       %w[git bundle].each do |tool|
         unless system("which", tool, out: File::NULL, err: File::NULL)
-          $stderr.puts "Error: #{tool} is not installed or not in PATH."
-          exit 1
+          raise Rwm::Error, "#{tool} is not installed or not in PATH."
         end
       end
     end
@@ -82,7 +80,7 @@ module Rwm
         Usage: rwm <command> [options]
         Commands:
-          init              Initialize a new rwm workspace
+          init [--vscode]   Initialize a new rwm workspace
           bootstrap         Install deps and run bootstrap tasks in all packages
           new <type> <name> Scaffold a new app or lib
           info <name>       Show details about a package
@@ -91,18 +89,31 @@ module Rwm
             --mermaid       Output in Mermaid format
           check             Validate dependency graph and conventions
           run <task> [pkg]  Run a rake task across all (or one) package(s)
-          test              Shortcut for `rwm run test`
           affected          Show packages affected by current changes
+            --base REF      Compare against REF instead of auto-detected base
+            --committed     Only consider committed changes
           list              List all packages in the workspace
+          cache clean [pkg] Clear cached task results
           help              Show this help
+          version           Show version
+        Any unrecognized command is treated as a task name:
+          rwm test          → rwm run test
+          rwm lint          → rwm run lint
-        Run options:
+        Run options (for `rwm run` and task shortcuts):
           --affected        Only run on affected packages
+          --committed       Only consider committed changes (with --affected)
+          --base REF        Compare against REF instead of auto-detected base
+          --dry-run         Show what would run without executing
           --no-cache        Bypass task-level caching
+          --buffered        Buffer output per-package
+          --concurrency N   Max parallel workers (default: CPU count)
-        Options:
+        Global options:
           -h, --help        Show this help
           -v, --version     Show version
+          --verbose         Enable debug logging (or set RWM_DEBUG=1)
       HELP
     end
   end

data/lib/rwm/commands/affected.rb CHANGED Viewed

@@ -8,13 +8,14 @@ module Rwm
       def initialize(argv)
         @argv = argv
         @committed_only = false
+        @base_branch = nil
         parse_options
       end
       def run
         workspace = Workspace.find
         graph = DependencyGraph.load(workspace)
-        detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only)
+        detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only, base_branch: @base_branch)
         affected = detector.affected_packages
         directly_changed = detector.directly_changed_packages
@@ -40,6 +41,9 @@ module Rwm
       def parse_options
         parser = OptionParser.new do |opts|
+          opts.on("--base REF", "Compare against REF instead of auto-detected base branch") do |ref|
+            @base_branch = ref
+          end
           opts.on("--committed", "Only consider committed changes (ignore staged/unstaged)") do
             @committed_only = true
           end

data/lib/rwm/commands/cache.rb ADDED Viewed

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Rwm
+  module Commands
+    class Cache
+      def initialize(argv)
+        @argv = argv
+      end
+      def run
+        subcommand = @argv.shift
+        case subcommand
+        when "clean"
+          clean
+        when nil
+          $stderr.puts "Usage: rwm cache clean [<package>]"
+          1
+        else
+          $stderr.puts "Unknown cache subcommand: #{subcommand}"
+          $stderr.puts "Usage: rwm cache clean [<package>]"
+          1
+        end
+      end
+      private
+      def clean
+        workspace = Workspace.find
+        package_name = @argv.shift
+        if package_name
+          workspace.find_package(package_name) # validates package exists
+          TaskCache.clean(workspace, package_name: package_name)
+          puts "Cleared cache for #{package_name}."
+        else
+          TaskCache.clean(workspace)
+          puts "Cleared all cached task results."
+        end
+        0
+      end
+    end
+  end
+end

data/lib/rwm/commands/graph.rb CHANGED Viewed

@@ -20,9 +20,9 @@ module Rwm
         case @format
         when :dot
-          puts graph.to_dot(workspace.root)
+          puts graph.to_dot
         when :mermaid
-          puts graph.to_mermaid(workspace.root)
+          puts graph.to_mermaid
         end
         0

data/lib/rwm/commands/init.rb CHANGED Viewed

@@ -44,9 +44,10 @@ module Rwm
         puts "Workspace initialized. Running bootstrap..."
         puts
-        # Call bootstrap as the last step
+        # Call bootstrap as the last step — return its exit code
         require "rwm/commands/bootstrap"
         Commands::Bootstrap.new([]).run
+        0
       end
       private

data/lib/rwm/commands/new.rb CHANGED Viewed

@@ -53,13 +53,14 @@ module Rwm
       end
       def scaffold(pkg_path, name, type)
-        FileUtils.mkdir_p(File.join(pkg_path, "lib", name))
+        source_dir = type == "lib" ? "lib" : "app"
+        FileUtils.mkdir_p(File.join(pkg_path, source_dir, name))
         FileUtils.mkdir_p(File.join(pkg_path, "spec"))
         write_gemfile(pkg_path, name)
         write_gemspec(pkg_path, name, type)
         write_rakefile(pkg_path, name)
-        write_lib_entry(pkg_path, name)
+        write_entry_file(pkg_path, name, type)
         write_spec_helper(pkg_path)
       end
@@ -94,8 +95,9 @@ module Rwm
           '',
         ]
         lines << '  spec.files = Dir.glob("lib/**/*")' if type == "lib"
+        source_dir = type == "lib" ? "lib" : "app"
         lines.concat([
-          '  spec.require_paths = ["lib"]',
+          "  spec.require_paths = [\"#{source_dir}\"]",
           '  spec.required_ruby_version = ">= 3.4.0"',
           'end',
           '',
@@ -121,8 +123,9 @@ module Rwm
         RAKEFILE
       end
-      def write_lib_entry(pkg_path, name)
-        File.write(File.join(pkg_path, "lib", "#{name}.rb"), <<~RUBY)
+      def write_entry_file(pkg_path, name, type)
+        source_dir = type == "lib" ? "lib" : "app"
+        File.write(File.join(pkg_path, source_dir, "#{name}.rb"), <<~RUBY)
           # frozen_string_literal: true
           module #{camelize(name)}

data/lib/rwm/commands/run.rb CHANGED Viewed

@@ -12,6 +12,8 @@ module Rwm
         @no_cache = false
         @buffered = false
         @concurrency = nil
+        @dry_run = false
+        @base_branch = nil
         parse_options
       end
@@ -19,7 +21,7 @@ module Rwm
         task = @argv.shift
         unless task
-          $stderr.puts "Usage: rwm run <task> [<package>] [--affected] [--no-cache] [--buffered] [--concurrency N]"
+          $stderr.puts "Usage: rwm run <task> [<package>] [--affected] [--base REF] [--dry-run] [--no-cache] [--buffered] [--concurrency N]"
           return 1
         end
@@ -29,14 +31,9 @@ module Rwm
         graph = DependencyGraph.load(workspace)
         packages = if package_name
-                     pkg = workspace.find_package(package_name)
-                     unless pkg
-                       $stderr.puts "Unknown package: #{package_name}"
-                       return 1
-                     end
-                     [pkg]
+                     [workspace.find_package(package_name)]
                    elsif @affected_only
-                     detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only)
+                     detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only, base_branch: @base_branch)
                      affected = detector.affected_packages
                      if affected.empty?
                        puts "No affected packages. Nothing to run."
@@ -53,13 +50,15 @@ module Rwm
           return 0
         end
-        # Filter to packages that have the requested rake task
-        runnable = packages.select { |pkg| pkg.has_rake_task?(task) }
+        # Filter to packages with a Rakefile (skip those without one entirely)
+        runnable = packages.select(&:has_rakefile?)
         if runnable.empty?
-          puts "No packages with a `#{task}` rake task found."
+          puts "No packages with a Rakefile found."
           return 0
         end
+        Rwm.debug("run: #{runnable.size} package(s) with Rakefiles")
         # Auto-detect cacheable tasks unless --no-cache
         cache = TaskCache.new(workspace, graph) unless @no_cache
         if cache
@@ -74,6 +73,12 @@ module Rwm
           return 0
         end
+        if @dry_run
+          puts "Dry run: would run `rake #{task}` on #{runnable.size} package(s):"
+          runnable.each { |pkg| puts "  #{pkg.name}" }
+          return 0
+        end
         puts "Running `rake #{task}` across #{runnable.size} package(s)..."
         puts
@@ -86,19 +91,33 @@ module Rwm
         if cache
           runner.results.each do |result|
             next unless result.success
+            next if result.skipped
             pkg = workspace.find_package(result.package_name)
             cache.store(pkg, task) if cache.cacheable?(pkg, task)
           end
         end
+        passed, rest = runner.results.partition { |r| r.success && !r.skipped }
+        failed, skipped = rest.partition { |r| !r.success }
+        skipped_from_rest = runner.results.select(&:skipped)
+        total = runner.results.size
+        parts = []
+        parts << "#{passed.size} passed" unless passed.empty?
+        parts << "#{failed.size} failed" unless failed.empty?
+        parts << "#{skipped_from_rest.size} skipped" unless skipped_from_rest.empty?
         puts
-        if runner.success?
-          puts "All packages passed."
+        puts "#{total} package(s): #{parts.join(", ")}."
+        Rwm.debug("passed: #{passed.map(&:package_name).join(", ")}") unless passed.empty?
+        Rwm.debug("skipped (no matching task): #{skipped_from_rest.map(&:package_name).join(", ")}") unless skipped_from_rest.empty?
+        if failed.empty?
           0
         else
-          failed = runner.failed_results
-          $stderr.puts "#{failed.size} package(s) failed:"
+          $stderr.puts "Failed:"
           failed.each { |r| $stderr.puts "  - #{r.package_name}" }
           1
         end
@@ -114,6 +133,12 @@ module Rwm
           opts.on("--committed", "Only consider committed changes (with --affected)") do
             @committed_only = true
           end
+          opts.on("--base REF", "Compare against REF instead of auto-detected base branch (with --affected)") do |ref|
+            @base_branch = ref
+          end
+          opts.on("--dry-run", "Show what would run without executing") do
+            @dry_run = true
+          end
           opts.on("--no-cache", "Bypass task caching even for cacheable tasks") do
             @no_cache = true
           end

data/lib/rwm/dependency_graph.rb CHANGED Viewed

@@ -61,7 +61,7 @@ module Rwm
     def topological_order
       tsort
     rescue TSort::Cyclic => e
-      raise CycleError, [e.message]
+      raise CycleError, [[e.message]]
     end
     # Group packages into execution levels — packages at the same level
@@ -79,7 +79,7 @@ module Rwm
           dependencies(name).all? { |dep| placed.include?(dep) }
         end
-        raise CycleError, ["Unable to resolve execution levels — possible cycle"] if level.empty?
+        raise CycleError, [["Unable to resolve execution levels — possible cycle"]] if level.empty?
         levels << level.sort
         remaining -= level
@@ -93,13 +93,16 @@ module Rwm
     def self.load(workspace)
       path = workspace.graph_path
       unless File.exist?(path)
+        Rwm.debug("graph: no cached graph found, building from scratch")
         return build_and_save(workspace)
       end
       if stale?(path, workspace.packages)
+        Rwm.debug("graph: cached graph is stale, rebuilding")
         return build_and_save(workspace)
       end
+      Rwm.debug("graph: loading from cache at #{path}")
       data = JSON.parse(File.read(path))
       graph = new
@@ -158,24 +161,7 @@ module Rwm
       File.write(path, JSON.pretty_generate(to_json_data) + "\n")
     end
-    def self.load_from_file(path)
-      data = JSON.parse(File.read(path))
-      graph = new
-      # We can't reconstruct full Package objects from JSON alone,
-      # but we can load the structure for validation
-      data["edges"]&.each do |name, deps|
-        graph.instance_variable_get(:@edges)[name] = deps
-        deps.each do |dep|
-          graph.instance_variable_get(:@dependents)[dep] ||= []
-          graph.instance_variable_get(:@dependents)[dep] << name
-        end
-      end
-      graph
-    end
-    def to_dot(workspace_root)
+    def to_dot
       lines = []
       lines << "digraph rwm {"
       lines << "  rankdir=LR;"
@@ -195,7 +181,7 @@ module Rwm
       lines.join("\n") + "\n"
     end
-    def to_mermaid(workspace_root)
+    def to_mermaid
       lines = []
       lines << "graph LR"

data/lib/rwm/gemfile.rb CHANGED Viewed

@@ -13,8 +13,15 @@
 require "bundler"
 require "open3"
+require "set"
 module Rwm
+  @resolved_libs = Set.new
+  def self.resolved_libs
+    @resolved_libs
+  end
   module GemfileDsl
     def rwm_workspace_root
       @rwm_workspace_root ||= begin
@@ -26,8 +33,41 @@ module Rwm
     end
     def rwm_lib(name, **opts)
-      path = File.join(rwm_workspace_root, "libs", name.to_s)
-      gem(name.to_s, **opts, path: path)
+      name = name.to_s
+      @rwm_resolved ||= Set.new
+      return if @rwm_resolved.include?(name)
+      @rwm_resolved.add(name)
+      Rwm.resolved_libs.add(name)
+      path = File.join(rwm_workspace_root, "libs", name)
+      gem(name, **opts, path: path)
+      # Resolve transitive workspace deps from the target lib's Gemfile
+      target_gemfile = File.join(path, "Gemfile")
+      return unless File.exist?(target_gemfile)
+      scan_transitive_deps(target_gemfile).each { |dep_name| rwm_lib(dep_name) }
+    end
+    private
+    def scan_transitive_deps(gemfile_path)
+      sandbox = Bundler::Dsl.new
+      sandbox.eval_gemfile(gemfile_path)
+      libs_prefix = File.join(rwm_workspace_root, "libs") + "/"
+      gemfile_dir = File.dirname(gemfile_path)
+      sandbox.dependencies.each_with_object([]) do |dep, result|
+        source = dep.source
+        next unless source.is_a?(Bundler::Source::Path)
+        dep_path = File.expand_path(source.path.to_s, gemfile_dir)
+        next unless dep_path.start_with?(libs_prefix)
+        result << File.basename(dep_path)
+      end
     end
   end

data/lib/rwm/package.rb CHANGED Viewed

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "pathname"
-require "open3"
 module Rwm
   class Package
@@ -25,31 +24,14 @@ module Rwm
       File.exist?(File.join(path, "Rakefile"))
     end
-    def has_rake_task?(task)
-      return false unless has_rakefile?
-      output, _, status = Open3.capture3("bundle", "exec", "rake", "-P", chdir: path)
-      return false unless status.success?
-      output.lines.any? { |line| line.strip == "rake #{task}" }
-    end
     def gemfile_path
       File.join(path, "Gemfile")
     end
-    def gemspec_path
-      Dir.glob(File.join(path, "*.gemspec")).first
-    end
     def relative_path(workspace_root)
       Pathname.new(path).relative_path_from(Pathname.new(workspace_root)).to_s
     end
-    def to_s
-      "#{name} (#{type})"
-    end
     def ==(other)
       other.is_a?(Package) && name == other.name && path == other.path
     end

data/lib/rwm/rails.rb ADDED Viewed

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# Rails integration for RWM workspaces.
+#
+# Usage in config/application.rb:
+#
+#   require_relative "boot"
+#   require "rwm/rails"
+#   Rwm.require_libs
+#   require "rails"
+require "rwm/gemfile"
+module Rwm
+  def self.require_libs
+    self.resolved_libs.each { |name| require name }
+  end
+end

data/lib/rwm/task_cache.rb CHANGED Viewed

@@ -7,6 +7,17 @@ require "open3"
 module Rwm
   class TaskCache
+    def self.clean(workspace, package_name: nil)
+      cache_dir = File.join(workspace.root, ".rwm", "cache")
+      return unless Dir.exist?(cache_dir)
+      if package_name
+        Dir.glob(File.join(cache_dir, "#{package_name}-*")).each { |f| File.delete(f) }
+      else
+        Dir.glob(File.join(cache_dir, "*")).each { |f| File.delete(f) }
+      end
+    end
     def initialize(workspace, graph)
       @workspace = workspace
       @graph = graph
@@ -25,20 +36,33 @@ module Rwm
     # Also verifies declared outputs exist (if any).
     def cached?(package, task)
       stored = read_stored_hash(package, task)
-      return false unless stored
-      return false unless stored == content_hash(package)
+      unless stored
+        Rwm.debug("cache miss: #{package.name}:#{task} (no stored hash)")
+        return false
+      end
+      current = content_hash(package)
+      unless stored == current
+        Rwm.debug("cache miss: #{package.name}:#{task} (hash changed)")
+        return false
+      end
       # If outputs are declared, they must exist
       decl = cache_declarations(package)[task]
       if decl && decl["output"]
-        return false unless outputs_exist?(package, decl["output"])
+        unless outputs_exist?(package, decl["output"])
+          Rwm.debug("cache miss: #{package.name}:#{task} (outputs missing)")
+          return false
+        end
       end
+      Rwm.debug("cache hit: #{package.name}:#{task}")
       true
     end
     # Store the current content hash after a successful task run
     def store(package, task)
+      Rwm.debug("cache store: #{package.name}:#{task}")
       FileUtils.mkdir_p(@cache_dir)
       path = cache_file(package, task)
       File.write(path, content_hash(package))
@@ -78,6 +102,7 @@ module Rwm
     def cache_declarations(package)
       return @cache_declarations[package.name] if @cache_declarations.key?(package.name)
+      Rwm.debug("cache declarations: discovering for #{package.name}")
       output, _, status = Open3.capture3("bundle", "exec", "rake", "rwm:cache_config", chdir: package.path)
       @cache_declarations[package.name] = if status.success? && !output.strip.empty?
                                              JSON.parse(output.strip)
@@ -91,13 +116,19 @@ module Rwm
     private
     def source_files(package)
-      Dir.glob(File.join(package.path, "**", "*"))
-         .select { |f| File.file?(f) }
-         .reject do |f|
-           rel = f.delete_prefix("#{package.path}/")
-           rel.start_with?("tmp/") || rel.start_with?("vendor/") || rel.start_with?(".bundle/")
-         end
-         .sort
+      # Tracked files + untracked-but-not-ignored files (null-delimited for safe filenames)
+      output, _, status = Open3.capture3(
+        "git", "ls-files", "-z", "--cached", "--others", "--exclude-standard",
+        chdir: package.path
+      )
+      return [] unless status.success?
+      files = output.split("\0")
+                    .reject(&:empty?)
+                    .sort
+                    .map { |f| File.join(package.path, f) }
+      Rwm.debug("source_files: #{package.name} → #{files.size} file(s)")
+      files
     end
     def cache_file(package, task)

data/lib/rwm/task_runner.rb CHANGED Viewed

@@ -5,7 +5,9 @@ require "etc"
 module Rwm
   class TaskRunner
-    Result = Struct.new(:package_name, :task, :success, :output, keyword_init: true)
+    Result = Struct.new(:package_name, :task, :success, :output, :skipped, keyword_init: true)
+    NO_TASK_PATTERN = /Don't know how to build task/
     attr_reader :results
@@ -28,16 +30,33 @@ module Rwm
       completed = Set.new
       skipped = Set.new
       running = {}
+      @interrupted = false
       mutex = Mutex.new
       condition = ConditionVariable.new
-      until pending.empty? && running.empty?
+      previous_trap = Signal.trap("INT") do
+        @interrupted = true
+        # Cannot use mutex inside trap context — just kill threads directly.
+        # Thread#kill is safe to call from trap context.
+        running.each_value { |t| t.kill rescue nil }
+      end
+      done = false
+      until done
+        break if @interrupted
         mutex.synchronize do
+          if pending.empty? && running.empty?
+            done = true
+            next
+          end
           ready = pending.select { |pkg| ready?(pkg, package_names, completed) }
           ready.each do |pkg|
             break if running.size >= @concurrency
+            break if @interrupted
             pending.delete(pkg)
             running[pkg.name] = Thread.new do
@@ -73,7 +92,11 @@ module Rwm
         end
       end
+      raise Interrupt, "Interrupted by Ctrl+C" if @interrupted
       @results
+    ensure
+      Signal.trap("INT", previous_trap || "DEFAULT")
     end
     # Run a rake task in each package
@@ -105,10 +128,23 @@ module Rwm
     def run_single(pkg, &command_proc)
       cmd = command_proc.call(pkg)
       prefix = "[#{pkg.name}]"
+      Rwm.debug("running: #{cmd.join(' ')} in #{pkg.path}")
       stdout, stderr, status = Open3.capture3(*cmd, chdir: pkg.path)
       output = format_output(prefix, stdout, stderr)
+      # Detect "task not found" and treat as skipped, not failed
+      if !status.success? && stderr.match?(NO_TASK_PATTERN)
+        Rwm.debug("#{pkg.name}: task not found, skipping")
+        return Result.new(
+          package_name: pkg.name,
+          task: cmd.join(" "),
+          success: true,
+          output: "",
+          skipped: true
+        )
+      end
       if @buffered
         print_buffered_output(pkg.name, output, status.success?)
       else

data/lib/rwm/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Rwm
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/rwm/workspace.rb CHANGED Viewed

@@ -33,14 +33,6 @@ module Rwm
       File.join(rwm_dir, GRAPH_FILE)
     end
-    def libs_dir
-      File.join(root, "libs")
-    end
-    def apps_dir
-      File.join(root, "apps")
-    end
     # Discover all packages by scanning libs/ and apps/ for directories with a Gemfile
     def packages
       @packages ||= discover_packages

data/lib/rwm.rb CHANGED Viewed

@@ -4,6 +4,20 @@ require_relative "rwm/version"
 require_relative "rwm/errors"
 module Rwm
+  @verbose = false
+  def self.verbose?
+    @verbose
+  end
+  def self.verbose=(value)
+    @verbose = value
+  end
+  def self.debug(msg)
+    $stderr.puts "[rwm debug] #{msg}" if @verbose
+  end
   autoload :Workspace,         "rwm/workspace"
   autoload :Package,           "rwm/package"
   autoload :GemfileParser,     "rwm/gemfile_parser"

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_workspace_manager
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Siddharth Bhatt
@@ -20,11 +20,14 @@ files:
 - LICENSE.txt
 - README.md
 - bin/rwm
+- completions/rwm.bash
+- completions/rwm.zsh
 - lib/rwm.rb
 - lib/rwm/affected_detector.rb
 - lib/rwm/cli.rb
 - lib/rwm/commands/affected.rb
 - lib/rwm/commands/bootstrap.rb
+- lib/rwm/commands/cache.rb
 - lib/rwm/commands/check.rb
 - lib/rwm/commands/graph.rb
 - lib/rwm/commands/info.rb
@@ -40,6 +43,7 @@ files:
 - lib/rwm/git_hooks.rb
 - lib/rwm/overcommit.rb
 - lib/rwm/package.rb
+- lib/rwm/rails.rb
 - lib/rwm/rake.rb
 - lib/rwm/task_cache.rb
 - lib/rwm/task_runner.rb
@@ -50,8 +54,8 @@ homepage: https://github.com/sidbhatt11/ruby-workspace-manager
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/sidbhatt11/ruby-workspace-manager
   source_code_uri: https://github.com/sidbhatt11/ruby-workspace-manager
+  changelog_uri: https://github.com/sidbhatt11/ruby-workspace-manager/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib