monoz 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95f85442889a0675ea32c6e1109e20201793b8a9933329103be401551b23438b
-  data.tar.gz: 81e4f563fc9797196c7bf5531030f5848da689e9e400fea3cdf28263c66dc99d
+  metadata.gz: 8690b4b3d6adc785adfa22b77c24f72fb2524aa57f337b9d58723b29d9c95e37
+  data.tar.gz: ffce67da4773d0a25c7c0844fcbe35e5ee21b6e8aff7ada1541e5cf7fdaf6feb
 SHA512:
-  metadata.gz: '08dad5e93a296263067bcf7e38621772bfd74c88a0258d07f7c3b72674c56c450211aeebc178bd0075c5626356039413c4d129eb38ee2545865d005e1ac43945'
-  data.tar.gz: 1858caeb0e79ceba16d373b79278a4acc031953963751e5c8815f43ff1691af9e4884002826963989ddd7dfdf9ace6588b3e199778dcbb3ebcec1de90b7b45d3
+  metadata.gz: bf09e686e3baddbe8bb618d7372044f0d862a0cbe2b2f787490d98b8d5dce1f40d0c78891c4a910c1d162c3998586d9d96e24671c49a8ea6f23b54d6a4f4fe2d
+  data.tar.gz: 21015ca0dbdf5b9ac345043415156003c1ed02e46244b0ca6f20858a8d9b9d99d35060d6f23a4f44ca9076c2ece7f6868466b0a73bbe660336de79284340f95d

data/README.md

@@ -2,7 +2,7 @@
 
 Monoz is a command-line tool that helps you manage your **ruby** monorepo. It provides an easy way to manage multiple related **ruby** projects and their dependencies in a single repository. Monoz helps you keep track of your projects and their interdependencies, making it easier to maintain and scale your codebase. 
 
-## Installation
+## Getting started
 
 You can install Monoz by running the following command:
 
@@ -10,8 +10,6 @@ You can install Monoz by running the following command:
 $ gem install monoz
 ```
 
-## Getting started
-
 To initialize a Monoz repository in the current directory, simply run:
 
 ```console
@@ -29,7 +27,9 @@ This will create a new Monoz repo with the following structure:
 └── monoz.yml
 ```
 
-### Adding projects
+## Projects
+
+### Add a project
 
 Once you've initialized your Monoz repository, you can start adding projects to it.
 
@@ -57,6 +57,13 @@ To bundle all the projects in the Monoz repository, simply run:
 
 ```console
 $ monoz bundle
+
+kiqr_core: bundle ✓
+content_api: bundle ✓
+core_api: bundle ✓
+kiqr_cloud: bundle ✓
+
+The command ran successfully in all projects without any errors.
 ```
 
 If you instead want to update the dependencies of your projects, you can use the `monoz bundle update` command. This command will update the `Gemfile.lock` file of each project based on the latest available versions of their dependencies.
@@ -65,33 +72,44 @@ To update the dependencies of all projects in the Monoz repository, simply run:
 
 ```console
 $ monoz bundle update
+
+kiqr_core: bundle update ✓
+content_api: bundle update ✓
+core_api: bundle update ✓
+kiqr_cloud: bundle update ✓
+
+The command ran successfully in all projects without any errors.
 ```
 
 Note that when you add a new dependency to a project, you'll need to run `monoz bundle` to update its `Gemfile.lock` file before you can use the new dependency. Similarly, if you update the dependencies of a project's `Gemfile`, you'll need to run `monoz bundle` to update its `Gemfile.lock` file with the new versions.
 
 #### Run other bundler commands
 
-You can also run other bundler commands on all projects in the repository using the `monoz bundle` command followed by the desired arguments. For example, to run the RSpec tests for all projects, you can use the following command:
+You can also run other bundler commands on all projects in the repository using the `monoz bundle` command followed by the desired arguments. For example, to run Rubocop tests in all projects, you can use the following command:
 
 ```console
-$ monoz bundle exec rspec
+$ monoz bundle exec rubocop
+
+kiqr_core: bundle exec rubocop ✓
+content_api: bundle exec rubocop ✗
+Configuration file not found: /some/path/.rubocop.yml
 
-[kiqr_core] bundle exec rspec
-[core_api] bundle exec rspec
-[content_api] bundle exec rspec
-[kiqr_cloud] bundle exec rspec
+core_api: bundle exec rubocop ✓
+kiqr_cloud: bundle exec rubocop ✓
+
+Error: The command bundle exec rubocop failed to run in one or more project directories
 ```
 
-This will execute the `bundle exec rspec` command in each project directory, ensuring that all the necessary dependencies are installed and loaded for each project. Similarly, you can run other bundler commands such as `bundle install`, `bundle update`, and so on, by appending the desired arguments to the `monoz bundle` command.
+This will execute the `bundle exec rubocop` command in each project directory, ensuring that all the necessary dependencies are installed and loaded for each project. Similarly, you can run other bundler commands such as `bundle install`, `bundle update`, and so on, by appending the desired arguments to the `monoz bundle` command.
 
-### Inspect projects
+### List projects
 
-You can inspect the projects in your Monoz repository using the `monoz inspect` command. This command will display a table that shows the projects in the repository, their type (app or gem), the gem name (if it's a gem), the test framework(s) used, and the projects that depend on them.
+You can inspect the projects in your Monoz repository using the `monoz projects` command. This command will display a table that shows the projects in the repository, their type (app or gem), the gem name (if it's a gem), the test framework(s) used, and the projects that depend on them.
 
-Here's an example output of the `monoz inspect` command:
+Here's an example output of the `monoz projects` command:
 
 ```console
-$ monoz inspect
+$ monoz projects
 
 o---------------o--------o-------------o---------------------o-------------------------------------o
 |  Project      |  Type  |  Gem Name   |  Test Framework(s)  |  Dependants                         |
@@ -103,6 +121,97 @@ o---------------o--------o-------------o---------------------o------------------
 o---------------o--------o-------------o---------------------o-------------------------------------o
 ```
 
+## Runing commands
+
+### Running commands in projects
+
+You can run any command in all projects of your Monoz repository using the `monoz run` command. Simply provide the command you want to run as an argument, and Monoz will execute it in each project directory.
+
+For example, to create an empty file named test.txt in the tmp/ directory of all projects, you can use the following command:
+
+```console
+$ monoz run touch tmp/test.txt
+
+kiqr_core: touch tmp/test.txt ✓
+content_api: touch tmp/test.txt ✓
+core_api: touch tmp/test.txt ✓
+kiqr_cloud: touch tmp/test.txt ✓
+
+The command ran successfully in all projects without any errors.
+```
+
+This will execute the `touch tmp/test.txt` command in each project directory, creating the test.txt file in the tmp/ directory. If a command fails to run in a project directory, Monoz will display an error message with the output of the command.
+
+Note that if you need to run a command in a specific project, you can simply navigate to the project directory and run the command as you would in a regular Ruby project. The monoz run command is primarily useful for running commands across one ore many projects in a Monoz repository at once.
+
+### Run in foreground / interactive mode
+
+You can run commands in interactive mode using the flag `--tty`, or `-t`:
+
+```console
+$ monoz run bin/dev --filter=example_com --tty
+
+example_com: bin/dev
+23:41:04 web.1  | started with pid 96841
+23:41:04 css.1  | started with pid 96842
+23:41:05 web.1  | => Booting Puma
+23:41:05 web.1  | => Rails 7.0.4.3 application starting in development 
+23:41:05 web.1  | => Run `bin/rails server --help` for more startup options
+23:41:06 web.1  | Puma starting in single mode...
+23:41:06 web.1  | * Puma version: 5.6.5 (ruby 3.2.0-p0) ("Birdie's Version")
+23:41:06 web.1  | *  Min threads: 5
+23:41:06 web.1  | *  Max threads: 5
+23:41:06 web.1  | *  Environment: development
+23:41:06 web.1  | *          PID: 96841
+23:41:06 web.1  | * Listening on http://127.0.0.1:3000
+23:41:06 web.1  | * Listening on http://[::1]:3000
+23:41:06 web.1  | Use Ctrl-C to stop
+23:41:06 css.1  | 
+23:41:06 css.1  | Rebuilding...
+23:41:06 css.1  | 
+23:41:06 css.1  | Done in 354ms.
+```
+
+### Filtering projects
+
+The `--filter` option in Monoz allows you to select certain projects based on specific criteria. This is useful if you only want to run a command on a specific subset of projects, rather than all of them. To use the `--filter` option, you simply specify a filter expression after the option. The filter expression is a comma-separated list of keywords that match the project names or tags in your Monoz configuration.
+
+For example, suppose you have a Monoz configuration with several projects, some of which are tagged as **apps** and some of which are tagged as **gems**. You can use the `--filter` option to select only the **apps** projects by running the following command:
+
+```console
+$ monoz bundle --filter=apps
+
+content_api: bundle ✓
+core_api: bundle ✓
+kiqr_cloud: bundle ✓
+
+The command ran successfully in all project directories without any errors.
+```
+
+Similarly, if you only want to list only gem projects, you can use the following command:
+
+```console
+$ monoz projects --filter=gems
+
+o-------------o--------o-------------o----------------------o-------------------------------------o
+|  Project    |  Type  |  Gem name   |  Found Framework(s)  |  Dependants                         |
+o-------------o--------o-------------o----------------------o-------------------------------------o
+|  kiqr_core  |  gem   |  kiqr_core  |  rspec               |  content_api, core_api, kiqr_cloud  |
+o-------------o--------o-------------o----------------------o-------------------------------------o
+```
+
+You can also use multiple keywords in the filter expression to select projects that match any of the keywords. For example, to run the `mrsk deploy` command on all **apps** and **apis** projects, you can use the following command:
+
+```console
+$ monoz run mrsk deploy --filter="apps,apis"
+```
+
+Finally, you can also specify individual project names in the filter expression. For example, to run the `rubocop` command on only the **gem1** and **gem2** projects, you can use the following command:
+
+```console
+$ monoz run rubocop --filter="gem1,gem2"
+```
+
 ## Contributing
 We welcome contributions from everyone! If you're interested in contributing to Monoz, please check out our contributing guidelines for more information.
 

data/bin/monoz

@@ -4,8 +4,12 @@
 require "monoz"
 
 begin
-  Monoz::Cli::Main.start(ARGV)
+  Monoz::Application.start(ARGV)
 rescue Monoz::Errors::ConfigurationNotFound
-  puts "This is not a valid Monoz directory."
+  puts "Error: This is not a valid Monoz directory."
   puts "Run monoz init to initialize Monoz in the current directory."
+  exit(1)
+rescue Monoz::Errors::StandardError => e
+  puts "Error: #{e.message}"
+  exit(1)
 end

data/lib/monoz/application.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+require "fileutils"
+
+module Monoz
+  class Application < Thor
+    class_option :tty, type: :boolean, aliases: ["--verbose", "-t"], default: false
+    class_option :filter
+
+    def initialize(*args)
+      super
+      Monoz.app = self
+    end
+
+    desc "init [PATH]", "Initialize a monozrepo at the specified PATH"
+    def init(path = ".")
+      Monoz::Services::InitService.new(self).call(path)
+    end
+
+    desc "bundle [COMMAND]", "Run bundle commands in all projects"
+    def bundle(*command)
+      return help("bundle") if command.nil? || command.first == "help"
+
+      projects = Monoz.projects.order(:dependants)
+      Monoz::Services::RunService.new(self).call(projects, "bundle", *command)
+
+      say "The command ran successfully in all project directories without any errors.", [:green]
+    end
+
+    desc "projects", "Shows a list of projects in this repository"
+    def projects
+      Monoz.projects.order(:name).to_table
+    end
+
+    map "run" => "run_action"
+    desc "run [COMMAND]", "Run commands in all projects"
+    def run_action(*command)
+      return help("run") if command.empty? || command.first == "help"
+
+      projects = Monoz.projects.order(:dependants)
+      Monoz::Services::RunService.new(self).call(projects, *command)
+
+      say "The command ran successfully in all project directories without any errors.", [:green]
+    end
+
+    desc "version", "Get the current version of Monoz"
+    def version
+      say "Monoz version: #{Monoz::VERSION}"
+    end
+  end
+end

data/lib/monoz/project.rb

@@ -2,7 +2,7 @@
 
 module Monoz
   class Project
-    attr_reader :name, :root_path, :gemspec, :type, :dependencies, :gem_name, :dependants
+    attr_reader :name, :root_path, :gemspec, :type, :dependencies, :gem_name, :dependants, :frameworks
 
     def initialize(root_path)
       @root_path = root_path
@@ -21,33 +21,27 @@ module Monoz
       @root_path != nil && gemfile_path != nil
     end
 
-    def run(*command)
-      FileUtils.chdir(root_path) do
-        system(*command)
-      end
-    end
-
     def text_color
       is_gem? ? :green : :blue
     end
 
-    def test_frameworks
-      frameworks = []
+    private
+      def find_frameworks
+        frameworks = []
 
-      rspec_files = Dir.glob(File.join(@root_path, "**/*_spec.rb"))
-      if !rspec_files.empty?
-        frameworks << "rspec"
-      end
+        rspec_files = Dir.glob(File.join(@root_path, "**/*_spec.rb"))
+        if !rspec_files.empty?
+          frameworks << "rspec"
+        end
 
-      minitest_files = Dir.glob(File.join(@root_path, "test/**/*_test.rb"))
-      if !minitest_files.empty?
-        frameworks << "minitest"
-      end
+        minitest_files = Dir.glob(File.join(@root_path, "test/**/*_test.rb"))
+        if !minitest_files.empty?
+          frameworks << "minitest"
+        end
 
-      frameworks
-    end
+        frameworks
+      end
 
-    private
       def parse_project_files
         @gemspec = parse_gemspec
       end
@@ -61,8 +55,7 @@ module Monoz
 
         spec = Gem::Specification.load(gemspec_file)
         {
-          name: spec.name,
-          version: spec.version.to_s
+          name: spec.name
         }
       end
 
@@ -70,7 +63,7 @@ module Monoz
         @name = File.basename(root_path)
         @gem_name = @gemspec.dig(:name) if is_gem?
         @type = is_gem? ? "gem" : "app"
-        @test_frameworks =
+        @frameworks = find_frameworks
         @dependants = []
       end
 

data/lib/monoz/project_collection.rb

@@ -51,27 +51,42 @@ module Monoz
       end
     end
 
-    def filter(key)
-      if key.to_sym == :apps
-        @items = @items.select { |i| i.type == "app" }
-        self
-      elsif key.to_sym == :gems
-        @items = @items.select { |i| i.type == "gem" }
-        self
-      else
-        raise "Invalid filter key: #{key}"
+    def filter(filters = [])
+      if filters.is_a?(String)
+        filters = filters.split(",").map(&:strip)
+      end
+      if filters.empty?
+        @items = []
+        return self
+      end
+      filtered_items = []
+      filters.each do |filter|
+        if filter == "gems"
+          filtered_items += @items.select { |i| i.type == "gem" }
+        elsif filter == "apps"
+          filtered_items += @items.select { |i| i.type == "app" }
+        else
+          project = find(filter)
+          if project
+            filtered_items << project
+          else
+            raise Monoz::Errors::StandardError.new("Invalid key: #{filter}")
+          end
+        end
       end
+      @items = filtered_items.uniq
+      self
     end
 
     def to_table
       rows = []
       @items.each do |project|
-        rows << [project.name, project.type, project.gem_name, project.test_frameworks.join(", "), project.dependants.join(", ")]
+        rows << [project.name, project.type, project.gem_name, project.frameworks.join(", "), project.dependants.join(", ")]
       end
       table = Terminal::Table.new(
-        headings: ["Project", "Type", "Gem Name", "Test Framework(s)", "Dependants"],
-        rows:,
-        style: { padding_left: 2, padding_right: 2, border_i: "o" },
+        headings: ["Project", "Type", "Gem name", "Found Framework(s)", "Dependants"],
+        rows: rows,
+        style: { padding_left: 2, padding_right: 2, border_i: "o" }
       )
       puts table
     end

data/lib/monoz/services/run_service.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require "open3"
+
+module Monoz
+  class Spinner
+    include Thor::Shell
+
+    def initialize(message, prefix: nil)
+      @spinner = nil
+      @message = message
+      @prefix = prefix
+    end
+
+    def start
+      @spinner = main
+      self
+    end
+
+    def success!
+      @spinner.kill
+      say_formatted(" \u2713 ", [:bold, :green])
+      say() # line break
+    end
+
+    def error!
+      @spinner.kill
+      say_formatted(" \u2717 ", [:bold, :red])
+      say() # line break
+    end
+
+    private
+      def reset
+        say("\r", nil, false)
+      end
+
+      def say_formatted(suffix, suffix_formatting = nil)
+        if @prefix != nil
+          say "\r[#{@prefix}] ", [:blue, :bold], nil
+          say @message, nil, false
+          say suffix, suffix_formatting, false
+        else
+          say "\r#{@message}", nil, false
+          say suffix, suffix_formatting, false
+        end
+      end
+
+      def main
+        spinner_count = 0
+
+        Thread.new do
+          loop do
+            dots = case spinner_count % 3
+                   when 0 then "."
+                   when 1 then ".."
+                   when 2 then "..."
+            end
+
+            say_formatted(dots)
+            spinner_count += 1
+            sleep(0.5)
+          end
+        end
+      end
+  end
+
+  module Services
+    class RunService < Monoz::Services::BaseService
+      attr_reader :errors, :warnings
+
+      def initialize(thor_instance)
+        @projects = nil
+        @errors = []
+        @warnings = []
+        super(thor_instance)
+      end
+
+      def success?
+        !errors? && !warnings?
+      end
+
+      def errors?
+        @errors.any?
+      end
+
+      def warnings?
+        @warnings.any?
+      end
+
+      def call(projects, *command)
+        raise ArgumentError.new("Missing command") if command.empty?
+
+        if projects.is_a?(Monoz::ProjectCollection)
+          @projects = projects.all
+        elsif projects.is_a?(Monoz::Project)
+          @projects = [projects]
+        else
+          raise "Invalid projects"
+        end
+
+        @projects.each do |project|
+          # say "#{project.name}: ", [:bold, :blue]
+          # Monoz.tty? ? say(command.join(" ")) : say("#{command.join(" ")} ")
+
+          if Monoz.tty?
+            say "[#{project.name}] ", [:blue, :bold], nil
+            say command.join(" ")
+          else
+            spinner = Monoz::Spinner.new(command.join(" "), prefix: project.name).start
+          end
+
+          response = run_commands_in_project(project, *command)
+
+          if response.success?
+            spinner.success! unless Monoz.tty?
+          else
+            spinner.error! unless Monoz.tty?
+            say response.output
+            say "" # line break
+            @errors << {
+              project: project.name,
+              command: command.join(" "),
+              exit_code: response.exit_code,
+              output: response.output
+            }
+          end
+        end
+
+        say ""
+
+        if errors?
+          say "Error: The command ", :red
+          say "#{command.join(" ")} ", [:red, :bold]
+          say "failed to run in one or more project directories", [:red]
+          exit(1)
+        end
+      end
+
+      private
+        def run_commands_in_project(project, *command)
+          raise ArgumentError.new("Invalid command") if command.empty?
+
+          output = ""
+          exit_status = nil
+
+          FileUtils.chdir(project.root_path) do
+            if Monoz.tty?
+              Open3.popen2e(*command.map { |arg| Shellwords.escape(arg) }) do |stdin, stdout_err, wait_thr|
+                while line = stdout_err.gets
+                  output += line
+                  print line
+                end
+
+                exit_status = wait_thr.value.exitstatus
+              end
+
+              say ""
+            else
+              output, status = Open3.capture2e(*command.map { |arg| Shellwords.escape(arg) })
+              exit_status = status.exitstatus
+            end
+          end
+
+          return Monoz::Responses::CaptureRunResponse.new(output, exit_status)
+        end
+    end
+  end
+end

data/lib/monoz/version.rb

@@ -1,3 +1,3 @@
 module Monoz
-  VERSION = "0.3.1"
+  VERSION = "0.4.1"
 end

data/lib/monoz.rb

@@ -3,36 +3,71 @@
 require_relative "monoz/version"
 
 require "pathname"
+require "shellwords"
 
 module Monoz
   module Errors
+    class StandardError < StandardError; end
     class ConfigurationNotFound < StandardError; end
   end
 
-  module Cli
-    autoload "Inspect", "monoz/cli/inspect"
-    autoload "Main", "monoz/cli/main"
-    autoload "Run", "monoz/cli/run"
+  module Responses
+    class CaptureRunResponse
+      attr_reader :output, :exit_code
+
+      def initialize(output, exit_code)
+        @output = output
+        @exit_code = exit_code
+      end
+
+      def success?
+        exit_code == 0
+      end
+
+      def error?
+        exit_code == 1
+      end
+    end
   end
 
   module Services
     autoload "BaseService", "monoz/services/base_service"
-    autoload "BundleService", "monoz/services/bundle_service"
     autoload "InitService", "monoz/services/init_service"
-    autoload "RunActionService", "monoz/services/run_action_service"
+    autoload "RunService", "monoz/services/run_service"
   end
 
+  autoload "Application", "monoz/application"
   autoload "Configuration", "monoz/configuration"
   autoload "Project", "monoz/project"
   autoload "ProjectCollection", "monoz/project_collection"
 
   class << self
+    def app
+      @app
+    end
+
+    def app=(value)
+      @app = value
+    end
+
     def config
       @config ||= Monoz::Configuration.new(pwd)
     end
 
+    def options
+      @app&.options
+    end
+
+    def tty?
+      Monoz.options.dig("tty") == true
+    end
+
     def projects
-      Monoz::ProjectCollection.new(config.root_path)
+      filter = Monoz.options&.dig("filter")
+      projects = Monoz::ProjectCollection.new(config.root_path)
+      projects = projects.filter(filter) unless filter.nil?
+
+      projects
     end
 
     def pwd

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monoz
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.1
 platform: ruby
 authors:
 - kjellberg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-04 00:00:00.000000000 Z
+date: 2023-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -64,15 +64,13 @@ files:
 - README.md
 - bin/monoz
 - lib/monoz.rb
-- lib/monoz/cli/inspect.rb
-- lib/monoz/cli/main.rb
+- lib/monoz/application.rb
 - lib/monoz/configuration.rb
 - lib/monoz/project.rb
 - lib/monoz/project_collection.rb
 - lib/monoz/services/base_service.rb
-- lib/monoz/services/bundle_service.rb
 - lib/monoz/services/init_service.rb
-- lib/monoz/services/run_action_service.rb
+- lib/monoz/services/run_service.rb
 - lib/monoz/version.rb
 homepage: https://github.com/kjellberg/monoz
 licenses:
@@ -89,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/monoz/cli/inspect.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-require "yaml"
-
-module Monoz
-  module Cli
-    class Inspect < Thor
-      default_task :all
-
-      desc "all", "Returns a list of all projects in this monozrepo"
-      def all
-        Monoz.projects.order(:name).to_table
-      end
-
-      desc "apps", "Returns a list of apps in this monozrepo"
-      def apps
-        Monoz.projects.order(:name).filter(:apps).to_table
-      end
-
-      desc "gems", "Returns a list of gems in this monozrepo"
-      def gems
-        Monoz.projects.filter(:gems).order(:name).to_table
-      end
-    end
-  end
-end

data/lib/monoz/cli/main.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-require "yaml"
-require "fileutils"
-
-module Monoz
-  module Cli
-    class Main < Thor
-      desc "init [PATH]", "Initialize a monozrepo at the specified PATH"
-      def init(path = ".")
-        Monoz::Services::InitService.new(self).call(path)
-      end
-
-      desc "bundle [COMMAND]", "Run bundle commands in all projects"
-      def bundle(*command)
-        Monoz::Services::BundleService.new(self).call(*command)
-      end
-
-      desc "inspect", "Inspect this monozrepo"
-      subcommand "inspect", Monoz::Cli::Inspect
-
-      map "run" => "run_action"
-      desc "run [action]", "Run commands in all projects"
-      def run_action(keys = nil)
-        return help("run") if keys.nil? || keys == "help"
-
-        Monoz::Services::RunActionService.new(self).call(keys)
-      end
-
-      desc "version", "Get the current version of Monoz"
-      def version
-        say "Monoz version: #{Monoz::VERSION}"
-      end
-    end
-  end
-end

data/lib/monoz/services/bundle_service.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "fileutils"
-require "active_support"
-
-module Monoz
-  module Services
-    class BundleService < Monoz::Services::BaseService
-      def call(*command)
-        Monoz.projects.order(:dependants).each do |project|
-          say "[#{project.name}] ", [:blue, :bold], false
-          say("bundle #{command.join(" ")}".strip, :green)
-          project.run "bundle", *command
-        end
-      end
-    end
-  end
-end

data/lib/monoz/services/run_action_service.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "fileutils"
-
-module Monoz
-  module Services
-    class RunActionService < Monoz::Services::BaseService
-      def call(keys = nil)
-        action = Monoz.config.dig("actions", *keys)
-
-        if action.nil?
-          say "Invalid action: ", :red, false
-          say keys, [:red, :bold]
-          exit 0
-        end
-
-        pp action
-        # Monoz.projects.order(:dependants).each do |project|
-        #   project.run "ls"
-        # end
-      end
-    end
-  end
-end