ruby_workspace_manager 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e8c287aa2d28cf7ed4c21f9ce567eb25f5a2164e0d064619aa2110676461ae0
+  data.tar.gz: b2d3ca1d17eecdf4b9233469bdaf24c4f43a9d7ec3cb6bd99fdb9fb2a527b419
+SHA512:
+  metadata.gz: 9b1c5e6dac68401d8ec61e70323af0bea421370354a5bfa36d66917bcd08222026b9ac535e800c1aa5f8405ffde6759381c53fecea629972f799e42e1176f4b2
+  data.tar.gz: a535d8642e4c5c3736a4606954e4a21a2d32e8926293d89ca2622fc3c8c0ced4b3667e0d5375b51c5b23cece660d76b1aa9e062cf270d73c001977b2e4a5ab7d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Siddharth Bhatt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+[![CI](https://github.com/sidbhatt11/ruby-workspace-manager/actions/workflows/ci.yml/badge.svg)](https://github.com/sidbhatt11/ruby-workspace-manager/actions/workflows/ci.yml)
+![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.4-red)
+
+# RWM — Ruby Workspace Manager
+
+An Nx-like monorepo tool for Ruby. Convention-over-configuration, zero runtime dependencies, delegates to Rake.
+
+## What it does
+
+RWM manages Ruby monorepos with multiple apps and libraries. It builds a dependency graph from your Gemfiles, enforces structural conventions, runs tasks in parallel respecting dependency order, detects affected packages from git changes, and caches results so unchanged work is never repeated.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `rwm init` | Initialize a workspace. |
+| `rwm bootstrap` | Install deps, build graph, install hooks, run bootstrap tasks. |
+| `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 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. |
+
+See [GUIDE.md](GUIDE.md) for full usage documentation — dependencies, caching, affected detection, git hooks, design decisions, and more.
+
+## License
+
+MIT

data/bin/rwm

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rwm"
+
+Rwm::CLI.run(ARGV)

data/lib/rwm/affected_detector.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Rwm
+  class AffectedDetector
+    attr_reader :workspace, :graph, :base_branch
+
+    def initialize(workspace, graph, committed_only: false)
+      @workspace = workspace
+      @graph = graph
+      @committed_only = committed_only
+      @base_branch = detect_base_branch
+    end
+
+    # Returns packages directly changed + their transitive dependents
+    def affected_packages
+      changed_files = detect_changed_files
+      directly_changed = map_files_to_packages(changed_files)
+
+      # If root-level files changed (outside any package), all packages are affected
+      root_files = changed_files.reject { |f| file_in_any_package?(f) }
+      unless root_files.empty?
+        return workspace.packages
+      end
+
+      # Collect transitive dependents of directly changed packages
+      all_affected = Set.new(directly_changed.map(&:name))
+      directly_changed.each do |pkg|
+        graph.transitive_dependents(pkg.name).each { |name| all_affected << name }
+      end
+
+      workspace.packages.select { |pkg| all_affected.include?(pkg.name) }
+    end
+
+    # Just the directly changed packages (no dependents)
+    def directly_changed_packages
+      changed_files = detect_changed_files
+      map_files_to_packages(changed_files)
+    end
+
+    private
+
+    def detect_base_branch
+      # Try to read the remote's default branch
+      ref = `git -C #{workspace.root} symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`.chomp
+      unless ref.empty?
+        # refs/remotes/origin/main → main
+        return ref.sub(%r{^refs/remotes/origin/}, "")
+      end
+
+      # Fall back: check if main or master exists
+      branches = `git -C #{workspace.root} branch --list main master 2>/dev/null`.lines.map(&:strip)
+      return "main" if branches.include?("main")
+      return "master" if branches.include?("master")
+
+      # Last resort
+      "main"
+    end
+
+    def detect_changed_files
+      files = Set.new
+
+      # 1. Committed changes: base branch vs HEAD
+      committed = `git -C #{workspace.root} diff --name-only #{base_branch}...HEAD 2>/dev/null`.chomp
+      committed.lines.each { |l| files << l.chomp }
+
+      unless @committed_only
+        # 2. Staged changes (not yet committed)
+        staged = `git -C #{workspace.root} diff --name-only --cached 2>/dev/null`.chomp
+        staged.lines.each { |l| files << l.chomp }
+
+        # 3. Unstaged working directory changes
+        unstaged = `git -C #{workspace.root} diff --name-only 2>/dev/null`.chomp
+        unstaged.lines.each { |l| files << l.chomp }
+      end
+
+      files.reject(&:empty?).to_a
+    end
+
+    def map_files_to_packages(files)
+      packages = workspace.packages
+      matched = Set.new
+
+      files.each do |file|
+        packages.each do |pkg|
+          rel_path = pkg.relative_path(workspace.root)
+          if file.start_with?("#{rel_path}/")
+            matched << pkg
+          end
+        end
+      end
+
+      matched.to_a
+    end
+
+    def file_in_any_package?(file)
+      workspace.packages.any? do |pkg|
+        rel_path = pkg.relative_path(workspace.root)
+        file.start_with?("#{rel_path}/")
+      end
+    end
+  end
+end

data/lib/rwm/cli.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rwm
+  class CLI
+    COMMANDS = {
+      "init"      => "Commands::Init",
+      "bootstrap" => "Commands::Bootstrap",
+      "new"       => "Commands::New",
+      "info"      => "Commands::Info",
+      "graph"     => "Commands::Graph",
+      "check"     => "Commands::Check",
+      "list"      => "Commands::List",
+      "run"       => "Commands::Run",
+      "affected"  => "Commands::Affected"
+    }.freeze
+
+    # Shortcuts that expand to `run <task>`
+    TASK_SHORTCUTS = %w[test spec build].freeze
+
+    def self.run(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      command_name = @argv.shift
+
+      if command_name.nil? || %w[-h --help help].include?(command_name)
+        print_help
+        return 0
+      end
+
+      if %w[-v --version version].include?(command_name)
+        puts "rwm #{Rwm::VERSION}"
+        return 0
+      end
+
+      # Expand task shortcuts: `rwm test` → `rwm run test`
+      if TASK_SHORTCUTS.include?(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}"
+      command_class = const_name.split("::").reduce(Rwm) { |mod, name| mod.const_get(name) }
+      command_class.new(@argv).run
+    rescue Rwm::Error => e
+      $stderr.puts "Error: #{e.message}"
+      1
+    end
+
+    private
+
+    def print_help
+      puts <<~HELP
+        rwm #{Rwm::VERSION} — Ruby Workspace Manager
+
+        Usage: rwm <command> [options]
+
+        Commands:
+          init              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
+          graph             Build and save the dependency graph
+            --dot           Output in Graphviz DOT format
+            --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
+          list              List all packages in the workspace
+          help              Show this help
+
+        Run options:
+          --affected        Only run on affected packages
+          --no-cache        Bypass task-level caching
+
+        Options:
+          -h, --help        Show this help
+          -v, --version     Show version
+      HELP
+    end
+  end
+end

data/lib/rwm/commands/affected.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rwm
+  module Commands
+    class Affected
+      def initialize(argv)
+        @argv = argv
+        @committed_only = false
+        parse_options
+      end
+
+      def run
+        workspace = Workspace.find
+        graph = DependencyGraph.load(workspace)
+        detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only)
+
+        affected = detector.affected_packages
+        directly_changed = detector.directly_changed_packages
+
+        if affected.empty?
+          puts "No packages affected."
+          return 0
+        end
+
+        puts "Base branch: #{detector.base_branch}"
+        puts "Affected packages (#{affected.size}):"
+        puts
+
+        affected.each do |pkg|
+          marker = directly_changed.include?(pkg) ? "(changed)" : "(dependent)"
+          puts "  #{pkg.name} #{marker}"
+        end
+
+        0
+      end
+
+      private
+
+      def parse_options
+        parser = OptionParser.new do |opts|
+          opts.on("--committed", "Only consider committed changes (ignore staged/unstaged)") do
+            @committed_only = true
+          end
+        end
+
+        parser.order!(@argv)
+      end
+    end
+  end
+end

data/lib/rwm/commands/bootstrap.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Rwm
+  module Commands
+    class Bootstrap
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def run
+        workspace = Workspace.find
+
+        bootstrap_root(workspace)
+        setup_hooks(workspace)
+
+        graph = DependencyGraph.build(workspace)
+        bootstrap_packages(workspace, graph)
+        save_graph(workspace, graph)
+        validate_conventions(workspace, graph)
+        update_vscode_workspace(workspace)
+
+        puts
+        puts "Bootstrap complete!"
+        0
+      end
+
+      private
+
+      def bootstrap_root(workspace)
+        puts "==> Bootstrapping workspace root..."
+        run_bundle_install(workspace.root)
+        run_rake_bootstrap(workspace.root)
+      end
+
+      def setup_hooks(workspace)
+        if File.exist?(File.join(workspace.root, ".overcommit.yml"))
+          puts "==> Setting up overcommit..."
+
+          overcommit = Overcommit.new(workspace.root)
+          if overcommit.setup
+            puts "  Overcommit configured."
+          else
+            $stderr.puts "  Warning: Could not install overcommit hooks."
+            $stderr.puts "  Run `overcommit --install` manually after installing the overcommit gem."
+            puts "  Hook scripts and config created (will activate once overcommit is installed)."
+          end
+        else
+          puts "==> Installing git hooks..."
+          hooks = GitHooks.new(workspace.root)
+          if hooks.setup
+            puts "  Git hooks installed."
+          else
+            $stderr.puts "  Warning: Could not install git hooks (no .git directory found)."
+          end
+        end
+      end
+
+      def bootstrap_packages(workspace, graph)
+        packages = workspace.packages
+        if packages.empty?
+          puts "==> No packages found. Skipping package bootstrap."
+          return
+        end
+
+        # Step 1: bundle install in all packages (parallel by execution level)
+        puts "==> Installing gems in #{packages.size} package(s)..."
+        install_runner = TaskRunner.new(graph, packages: packages)
+        install_runner.run_command do |pkg|
+          ["bundle", "install"]
+        end
+
+        unless install_runner.success?
+          failed = install_runner.failed_results
+          raise BootstrapError, "bundle install failed in: #{failed.map(&:package_name).join(", ")}"
+        end
+
+        # Step 2: rake bootstrap in all packages (parallel by execution level)
+        bootstrappable = packages.select(&:has_rakefile?)
+        unless bootstrappable.empty?
+          puts
+          puts "==> Running bootstrap tasks in #{bootstrappable.size} package(s)..."
+          bootstrap_runner = TaskRunner.new(graph, packages: bootstrappable)
+          bootstrap_runner.run_command do |pkg|
+            ["bundle", "exec", "rake", "bootstrap"]
+          end
+
+          unless bootstrap_runner.success?
+            failed = bootstrap_runner.failed_results
+            raise BootstrapError, "rake bootstrap failed in: #{failed.map(&:package_name).join(", ")}"
+          end
+        end
+      end
+
+      def save_graph(workspace, graph)
+        puts
+        puts "==> Saving dependency graph..."
+        graph.save(workspace.graph_path, workspace.root)
+        puts "  Graph saved to .rwm/graph.json (#{graph.packages.size} packages, #{graph.edges.values.flatten.size} edges)"
+      end
+
+      def validate_conventions(_workspace, graph)
+        puts "==> Validating conventions..."
+        checker = ConventionChecker.new(graph)
+        violations = checker.check
+
+        if violations.empty?
+          puts "  All conventions passed."
+        else
+          $stderr.puts "Convention violations found:"
+          violations.each { |v| $stderr.puts "  - #{v}" }
+        end
+      end
+
+      def update_vscode_workspace(workspace)
+        vscode = VscodeWorkspace.new(workspace.root)
+        return unless File.exist?(vscode.file_path)
+
+        vscode.generate(workspace.packages)
+      end
+
+      def run_bundle_install(dir)
+        return unless File.exist?(File.join(dir, "Gemfile"))
+
+        puts "  bundle install..."
+        success = system("bundle", "install", chdir: dir)
+        unless success
+          raise BootstrapError, "bundle install failed in #{dir}"
+        end
+      end
+
+      def run_rake_bootstrap(dir)
+        return unless File.exist?(File.join(dir, "Rakefile"))
+
+        # Check if bootstrap task exists before running it
+        has_task = system("bundle", "exec", "rake", "-s", "-T", "bootstrap",
+                          chdir: dir, out: File::NULL, err: File::NULL)
+        return unless has_task
+
+        puts "  rake bootstrap..."
+        success = system("bundle", "exec", "rake", "bootstrap", chdir: dir)
+        unless success
+          raise BootstrapError, "rake bootstrap failed in #{dir}"
+        end
+      end
+    end
+  end
+end

data/lib/rwm/commands/check.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rwm
+  module Commands
+    class Check
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def run
+        workspace = Workspace.find
+        graph = DependencyGraph.load(workspace)
+        checker = ConventionChecker.new(graph)
+        violations = checker.check
+
+        if violations.empty?
+          puts "  All conventions passed."
+          0
+        else
+          $stderr.puts "Convention violations found:"
+          violations.each { |v| $stderr.puts "  - #{v}" }
+          1
+        end
+      end
+    end
+  end
+end

data/lib/rwm/commands/graph.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rwm
+  module Commands
+    class Graph
+      def initialize(argv)
+        @argv = argv
+        @format = nil
+        parse_options
+      end
+
+      def run
+        workspace = Workspace.find
+        graph = DependencyGraph.build(workspace)
+        graph.save(workspace.graph_path, workspace.root)
+
+        puts "  Graph saved to .rwm/graph.json (#{graph.packages.size} packages, #{graph.edges.values.flatten.size} edges)"
+
+        case @format
+        when :dot
+          puts graph.to_dot(workspace.root)
+        when :mermaid
+          puts graph.to_mermaid(workspace.root)
+        end
+
+        0
+      end
+
+      private
+
+      def parse_options
+        OptionParser.new do |opts|
+          opts.on("--dot", "Output graph in Graphviz DOT format") do
+            @format = :dot
+          end
+
+          opts.on("--mermaid", "Output graph in Mermaid format") do
+            @format = :mermaid
+          end
+        end.parse!(@argv)
+      end
+    end
+  end
+end

data/lib/rwm/commands/info.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rwm
+  module Commands
+    class Info
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def run
+        name = @argv.shift
+
+        unless name
+          $stderr.puts "Usage: rwm info <package_name>"
+          return 1
+        end
+
+        workspace = Workspace.find
+        pkg = workspace.find_package(name)
+        graph = DependencyGraph.load(workspace)
+
+        deps = graph.dependencies(name)
+        dependents = graph.direct_dependents(name)
+        transitive = graph.transitive_dependents(name)
+
+        puts "Package:      #{pkg.name}"
+        puts "Type:         #{pkg.type}"
+        puts "Path:         #{pkg.relative_path(workspace.root)}"
+        puts "Has Rakefile: #{pkg.has_rakefile? ? "yes" : "no"}"
+        puts "Dependencies: #{deps.empty? ? "(none)" : deps.sort.join(", ")}"
+        puts "Dependents:   #{dependents.empty? ? "(none)" : dependents.sort.join(", ")}"
+
+        if transitive.size > dependents.size
+          puts "Transitive:   #{transitive.sort.join(", ")}"
+        end
+
+        0
+      end
+    end
+  end
+end