packs 0.0.6 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e86a9d19597b2dfda0fbec5013807777eff3e36d4fee72dfd445134a87f84d5
-  data.tar.gz: 1720911eabcb3bba3ea855ad953778c7f25085b581a1a4f5f3bbedfcc6458c92
+  metadata.gz: b263107f82d4798835847954ad1e85d0e62312ca9a8064ebf5ba789f522e3b3f
+  data.tar.gz: 90613f4569258bbfce8bcf2ceab4ac1038fc7a05ba2610376253ac7c8bd6e264
 SHA512:
-  metadata.gz: d96c70a719cb28a36dd7f3cc2e4a8c1b4fa0e827ef77a28a8aeab90e877a55208d12483c7e9465c605ffe997243ed1cbdaf0f1ebd593baf2f0da4ad489417272
-  data.tar.gz: d047fa7748598d907a70fa314aefd6943130999992266c2b28699cd522f45ee661be3b7afd7674edb11cf35cad83b8ae3e3654d905673bb37b73ba8a0b68f0a2
+  metadata.gz: 7173bc07d22465d0dc96041adc9e22e704429b1b0cb0b480240e2af8307bf7a47fc43a94e00768903dc588db89f5cb4445d3198de59a0463447b53cf02010716
+  data.tar.gz: 3cbfbc39d85ffd72e0c9a595a9dbeb60596b60b55cf909188bbbfc15aa7a44c59a098beda1916773f7cc16334a43d6a029b479dbc6c9bdc789a45f0d4e90ab84

data/README.md

@@ -1,16 +1,132 @@
 # packs
 
-Welcome to `packs`! `packs` are a simple ruby specification for an extensible packaging system to help modularize Ruby applications.
+`packs` are a specification for an extensible packaging system to help modularize Ruby applications.
 
-A `pack` (also called `package`) is a folder of Ruby code with a `package.yml` at the root that is intended to represent a well-modularized domain, and the rest of the [rubyatscale](https://github.com/rubyatscale) ecosystem is intended to help make the boundaries between a pack and any other more clear.
+A `pack` (short for `package`) is a folder of Ruby code with a `package.yml` at the root that is intended to represent a well-modularized domain.
+
+This gem provides a development CLI, `bin/packs`, to make using `packs` easier.
+
+# Configuration
+By default, this library will look for `packs` in the folder `packs/*/package.yml` (as well as nested packs at `packs/*/*/package.yml`). To change where `packs` are located, create a `packs.yml` file:
+```yml
+pack_paths:
+  - "{packs,utilities,deprecated}/*" # packs with multiple roots!
+  - "{packs,utilities,deprecated}/*/*" # nested packs!
+  - gems/* # gems can be packs too!
+```
+
+# Ecosystem
+The rest of the [rubyatscale](https://github.com/rubyatscale) ecosystem is intended to help make using packs and improving the boundaries between them more clear.
 
 Here are some example integrations with `packs`:
-- [`stimpack`](https://github.com/rubyatscale/stimpack) can be used to integrate `packs` into your `rails` application
+- [`packs-specification`](https://github.com/rubyatscale/packs-specification) is a low-dependency gem that allows your production environment to query simple information about packs
+- [`packs-rails`](https://github.com/rubyatscale/packs-rails) can be used to integrate `packs` into your `rails` application
 - [`rubocop-packs`](https://github.com/rubyatscale/rubocop-packs) contains cops to improve boundaries around `packs` 
 - [`packwerk`](https://github.com/Shopify/packwerk) and [`packwerk-extensions`](https://github.com/rubyatscale/packwerk-extensions) help you describe and constrain your package graph in terms of dependencies between packs and pack public API
 - [`code_ownership`](https://github.com/rubyatscale/code_ownership) gives your application the capability to determine the owner of a pack
-- [`use_packs`](https://github.com/rubyatscale/use_packs) gives a CLI, `bin/packs`, that makes it easy to create new packs, move files between packs, and more.
 - [`pack_stats`](https://github.com/rubyatscale/pack_stats) makes it easy to send metrics about pack adoption and modularization to your favorite metrics provider, such as DataDog (which has built-in support).
 
 # How is a pack different from a gem?
 A ruby [`gem`](https://guides.rubygems.org/what-is-a-gem/) is the Ruby community solution for packaging and distributing Ruby code. A gem is a great place to start new projects, and a great end state for code that's been extracted from an existing codebase. `packs` are intended to help gradually modularize an application that has some conceptual boundaries, but is not yet ready to be factored into gems.
+
+## Usage
+Make sure to run `bundle binstub packs` to generate `bin/packs` within your application.
+
+## CLI Documentation
+## Describe available commands or one specific command
+`bin/packs help [COMMAND]`
+
+## Create pack with name packs/your_pack
+`bin/packs create packs/your_pack`
+
+## Add packs/to_pack to packs/from_pack/package.yml list of dependencies
+`bin/packs add_dependency packs/from_pack packs/to_pack`
+
+Use this to add a dependency between packs.
+
+When you use bin/packs add_dependency packs/from_pack packs/to_pack, this command will
+modify packs/from_pack/package.yml's list of dependencies and add packs/to_pack.
+
+This command will also sort the list and make it unique.
+
+## List the top dependency violations of packs/your_pack
+`bin/packs list_top_dependency_violations packs/your_pack`
+
+Want to see who is depending on you? Not sure how your pack's code is being used in an unstated way
+
+You can use this command to list the top dependency violations.
+
+If no pack name is passed in, this will list out violations across all packs.
+
+## List the top privacy violations of packs/your_pack
+`bin/packs list_top_privacy_violations packs/your_pack`
+
+Want to create interfaces? Not sure how your pack's code is being used?
+
+You can use this command to list the top privacy violations.
+
+If no pack name is passed in, this will list out violations across all packs.
+
+## Make files or directories public API
+`bin/packs make_public path/to/file.rb path/to/directory`
+
+This moves a file or directory to public API (that is -- the `app/public` folder).
+
+Make sure there are no spaces between the comma-separated list of paths of directories.
+
+## Move files or directories from one pack to another
+`bin/packs move packs/destination_pack path/to/file.rb path/to/directory`
+
+This is used for moving files into a pack (the pack must already exist).
+Note this works for moving files to packs from the monolith or from other packs
+
+Make sure there are no spaces between the comma-separated list of paths of directories.
+
+## Lint `package_todo.yml` files to check for formatting issues
+`bin/packs lint_package_todo_yml_files`
+
+## Lint `package.yml` files
+`bin/packs lint_package_yml_files [ packs/my_pack packs/my_other_pack ]`
+
+## Run bin/packwerk validate (detects cycles)
+`bin/packs validate`
+
+## Run bin/packwerk check
+`bin/packs check [ packs/my_pack ]`
+
+## Run bin/packwerk update-todo
+`bin/packs update`
+
+## Get info about size and violations for packs
+`bin/packs get_info [ packs/my_pack packs/my_other_pack ]`
+
+## Visualize packs
+`bin/packs visualize [ packs/my_pack packs/my_other_pack ]`
+
+## Rename a pack
+`bin/packs rename`
+
+## Set packs/child_pack as a child of packs/parent_pack
+`bin/packs move_to_parent packs/child_pack packs/parent_pack `
+
+
+## Releasing
+Releases happen automatically through github actions once a version update is committed to `main`.
+
+## Discussions, Issues, Questions, and More
+To keep things organized, here are some recommended homes:
+
+### Issues:
+https://github.com/rubyatscale/packs/issues
+
+### Questions:
+https://github.com/rubyatscale/packs/discussions/categories/q-a
+
+### General discussions:
+https://github.com/rubyatscale/packs/discussions/categories/general
+
+### Ideas, new features, requests for change:
+https://github.com/rubyatscale/packs/discussions/categories/ideas
+
+### Showcasing your work:
+https://github.com/rubyatscale/packs/discussions/categories/show-and-tell

data/bin/packs

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# typed: strict
+
+require_relative '../lib/packs'
+
+if ARGV.empty?
+  Packs.start_interactive_mode!
+else
+  Packs::CLI.start(ARGV)
+end

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rubocop', 'rubocop')

data/bin/tapioca

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('tapioca', 'tapioca')

data/lib/packs/cli.rb

@@ -0,0 +1,164 @@
+# typed: strict
+
+require 'thor'
+
+module Packs
+  class CLI < Thor
+    extend T::Sig
+
+    desc 'create packs/your_pack', 'Create pack with name packs/your_pack'
+    sig { params(pack_name: String).void }
+    def create(pack_name)
+      Packs.create_pack!(pack_name: pack_name)
+    end
+
+    desc 'add_dependency packs/from_pack packs/to_pack', 'Add packs/to_pack to packs/from_pack/package.yml list of dependencies'
+    long_desc <<~LONG_DESC
+      Use this to add a dependency between packs.
+
+      When you use bin/packs add_dependency packs/from_pack packs/to_pack, this command will
+      modify packs/from_pack/package.yml's list of dependencies and add packs/to_pack.
+
+      This command will also sort the list and make it unique.
+    LONG_DESC
+    sig { params(from_pack: String, to_pack: String).void }
+    def add_dependency(from_pack, to_pack)
+      Packs.add_dependency!(
+        pack_name: from_pack,
+        dependency_name: to_pack
+      )
+    end
+
+    desc 'list_top_dependency_violations packs/your_pack', 'List the top dependency violations of packs/your_pack'
+    long_desc <<~LONG_DESC
+      Want to see who is depending on you? Not sure how your pack's code is being used in an unstated way
+
+      You can use this command to list the top dependency violations.
+
+      If no pack name is passed in, this will list out violations across all packs.
+    LONG_DESC
+    option :limit, type: :numeric, default: 10, aliases: :l, banner: 'Specify the limit of constants to analyze'
+    sig { params(pack_name: String).void }
+    def list_top_dependency_violations(pack_name)
+      Packs.list_top_dependency_violations(
+        pack_name: pack_name,
+        limit: options[:limit]
+      )
+    end
+
+    desc 'list_top_privacy_violations packs/your_pack', 'List the top privacy violations of packs/your_pack'
+    long_desc <<~LONG_DESC
+      Want to create interfaces? Not sure how your pack's code is being used?
+
+      You can use this command to list the top privacy violations.
+
+      If no pack name is passed in, this will list out violations across all packs.
+    LONG_DESC
+    option :limit, type: :numeric, default: 10, aliases: :l, banner: 'Specify the limit of constants to analyze'
+    sig { params(pack_name: String).void }
+    def list_top_privacy_violations(pack_name)
+      Packs.list_top_privacy_violations(
+        pack_name: pack_name,
+        limit: options[:limit]
+      )
+    end
+
+    desc 'make_public path/to/file.rb path/to/directory', 'Make files or directories public API'
+    long_desc <<~LONG_DESC
+      This moves a file or directory to public API (that is -- the `app/public` folder).
+
+      Make sure there are no spaces between the comma-separated list of paths of directories.
+    LONG_DESC
+    sig { params(paths: String).void }
+    def make_public(*paths)
+      Packs.make_public!(
+        paths_relative_to_root: paths,
+        per_file_processors: [Packs::RubocopPostProcessor.new, Packs::CodeOwnershipPostProcessor.new]
+      )
+    end
+
+    desc 'move packs/destination_pack path/to/file.rb path/to/directory', 'Move files or directories from one pack to another'
+    long_desc <<~LONG_DESC
+      This is used for moving files into a pack (the pack must already exist).
+      Note this works for moving files to packs from the monolith or from other packs
+
+      Make sure there are no spaces between the comma-separated list of paths of directories.
+    LONG_DESC
+    sig { params(pack_name: String, paths: String).void }
+    def move(pack_name, *paths)
+      Packs.move_to_pack!(
+        pack_name: pack_name,
+        paths_relative_to_root: paths,
+        per_file_processors: [Packs::RubocopPostProcessor.new, Packs::CodeOwnershipPostProcessor.new]
+      )
+    end
+
+    desc 'lint_package_todo_yml_files', 'Lint `package_todo.yml` files to check for formatting issues'
+    sig { void }
+    def lint_package_todo_yml_files
+      Packs.lint_package_todo_yml_files!
+    end
+
+    desc 'lint_package_yml_files [ packs/my_pack packs/my_other_pack ]', 'Lint `package.yml` files'
+    sig { params(pack_names: String).void }
+    def lint_package_yml_files(*pack_names)
+      Packs.lint_package_yml_files!(parse_pack_names(pack_names))
+    end
+
+    desc 'validate', 'Run bin/packwerk validate (detects cycles)'
+    sig { void }
+    def validate
+      system('bin/packwerk validate')
+    end
+
+    desc 'check [ packs/my_pack ]', 'Run bin/packwerk check'
+    sig { params(paths: String).void }
+    def check(*paths)
+      Packs.execute(['check', *paths])
+    end
+
+    desc 'update', 'Run bin/packwerk update-todo'
+    sig { void }
+    def update
+      system('bin/packwerk update-todo')
+    end
+
+    desc 'get_info [ packs/my_pack packs/my_other_pack ]', 'Get info about size and violations for packs'
+    sig { params(pack_names: String).void }
+    def get_info(*pack_names)
+      Private.get_info(packs: parse_pack_names(pack_names))
+    end
+
+    desc 'visualize [ packs/my_pack packs/my_other_pack ]', 'Visualize packs'
+    sig { params(pack_names: String).void }
+    def visualize(*pack_names)
+      Private.visualize(packs: parse_pack_names(pack_names))
+    end
+
+    desc 'rename', 'Rename a pack'
+    sig { void }
+    def rename
+      puts Private.rename_pack
+    end
+
+    desc 'move_to_parent packs/child_pack packs/parent_pack ', 'Set packs/child_pack as a child of packs/parent_pack'
+    sig { params(child_pack_name: String, parent_pack_name: String).void }
+    def move_to_parent(child_pack_name, parent_pack_name)
+      Packs.move_to_parent!(
+        parent_name: parent_pack_name,
+        pack_name: child_pack_name,
+        per_file_processors: [Packs::RubocopPostProcessor.new, Packs::CodeOwnershipPostProcessor.new]
+      )
+    end
+
+    private
+
+    # This is used by thor to know that these private methods are not intended to be CLI commands
+    no_commands do
+      sig { params(pack_names: T::Array[String]).returns(T::Array[Packs::Pack]) }
+      def parse_pack_names(pack_names)
+        pack_names.empty? ? Packs.all : pack_names.map { |p| Packs.find(p.gsub(%r{/$}, '')) }.compact
+      end
+    end
+  end
+end

data/lib/packs/code_ownership_post_processor.rb

@@ -0,0 +1,58 @@
+# typed: strict
+
+module Packs
+  class CodeOwnershipPostProcessor
+    include PerFileProcessorInterface
+    extend T::Sig
+
+    sig { void }
+    def initialize
+      @teams = T.let([], T::Array[String])
+      @did_move_files = T.let(false, T::Boolean)
+    end
+
+    sig { override.params(file_move_operation: Private::FileMoveOperation).void }
+    def before_move_file!(file_move_operation)
+      relative_path_to_origin = file_move_operation.origin_pathname
+      relative_path_to_destination = file_move_operation.destination_pathname
+
+      code_owners_allow_list_file = Pathname.new('config/code_ownership.yml')
+      return if !code_owners_allow_list_file.exist?
+
+      Packs.replace_in_file(
+        file: code_owners_allow_list_file.to_s,
+        find: relative_path_to_origin,
+        replace_with: relative_path_to_destination
+      )
+
+      team = CodeOwnership.for_file(relative_path_to_origin.to_s)
+
+      if team
+        @teams << team.name
+      else
+        @teams << 'Unknown'
+      end
+
+      pack = Packs.find(file_move_operation.destination_pack.name)
+      if pack && !CodeOwnership.for_package(pack).nil?
+        CodeOwnership.remove_file_annotation!(relative_path_to_origin.to_s)
+        @did_move_files = true
+      end
+    end
+
+    sig { params(file_move_operations: T::Array[Private::FileMoveOperation]).void }
+    def after_move_files!(file_move_operations)
+      if @teams.any?
+        Logging.section('Code Ownership') do
+          Logging.print('This section contains info about the current ownership distribution of the moved files.')
+          @teams.group_by { |team| team }.sort_by { |_team, instances| -instances.count }.each do |team, instances|
+            Logging.print "  #{team} - #{instances.count} files"
+          end
+          if @did_move_files
+            Logging.print 'Since the destination package has package-based ownership, file-annotations were removed from moved files.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/packs/configuration.rb

@@ -0,0 +1,61 @@
+# typed: strict
+
+require 'packs/user_event_logger'
+require 'packs/default_user_event_logger'
+
+module Packs
+  class Configuration
+    extend T::Sig
+
+    sig { params(enforce_dependencies: T::Boolean).void }
+    attr_writer :enforce_dependencies
+
+    sig { returns(UserEventLogger) }
+    attr_accessor :user_event_logger
+
+    OnPackageTodoLintFailure = T.type_alias do
+      T.proc.params(output: String).void
+    end
+
+    sig { returns(OnPackageTodoLintFailure) }
+    attr_accessor :on_package_todo_lint_failure
+
+    sig { void }
+    def initialize
+      @enforce_dependencies = T.let(default_enforce_dependencies, T::Boolean)
+      @user_event_logger = T.let(DefaultUserEventLogger.new, UserEventLogger)
+      @on_package_todo_lint_failure = T.let(->(output) {}, OnPackageTodoLintFailure)
+    end
+
+    sig { returns(T::Boolean) }
+    def enforce_dependencies
+      @enforce_dependencies
+    end
+
+    sig { void }
+    def bust_cache!
+      @enforce_dependencies = default_enforce_dependencies
+    end
+
+    sig { returns(T::Boolean) }
+    def default_enforce_dependencies
+      true
+    end
+  end
+
+  class << self
+    extend T::Sig
+
+    sig { returns(Configuration) }
+    def config
+      Private.load_client_configuration
+      @config = T.let(@config, T.nilable(Configuration))
+      @config ||= Configuration.new
+    end
+
+    sig { params(blk: T.proc.params(arg0: Configuration).void).void }
+    def configure(&blk)
+      yield(config)
+    end
+  end
+end

data/lib/packs/default_user_event_logger.rb

@@ -0,0 +1,7 @@
+# typed: strict
+
+module Packs
+  class DefaultUserEventLogger
+    include UserEventLogger
+  end
+end

data/lib/packs/logging.rb

@@ -0,0 +1,37 @@
+# typed: strict
+
+require 'colorized_string'
+
+module Packs
+  module Logging
+    extend T::Sig
+
+    sig { params(title: String, block: T.proc.void).void }
+    def self.section(title, &block)
+      print_divider
+      out ColorizedString.new(title).green.bold
+      out "\n"
+      yield
+    end
+
+    sig { params(text: String).void }
+    def self.print_bold_green(text)
+      out ColorizedString.new(text).green.bold
+    end
+
+    sig { params(text: String).void }
+    def self.print(text)
+      out text
+    end
+
+    sig { void }
+    def self.print_divider
+      out '=' * 100
+    end
+
+    sig { params(str: String).void }
+    def self.out(str)
+      puts str
+    end
+  end
+end

data/lib/packs/per_file_processor_interface.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+module Packs
+  module PerFileProcessorInterface
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { abstract.params(file_move_operation: Private::FileMoveOperation).void }
+    def before_move_file!(file_move_operation); end
+
+    sig { params(file_move_operations: T::Array[Private::FileMoveOperation]).void }
+    def after_move_files!(file_move_operations)
+      nil
+    end
+  end
+end

data/lib/packs/private/file_move_operation.rb

@@ -0,0 +1,80 @@
+# typed: strict
+
+module Packs
+  module Private
+    class FileMoveOperation < T::Struct
+      extend T::Sig
+
+      const :origin_pathname, Pathname
+      const :destination_pathname, Pathname
+      const :destination_pack, ParsePackwerk::Package
+
+      sig { returns(ParsePackwerk::Package) }
+      def origin_pack
+        ParsePackwerk.package_from_path(origin_pathname)
+      end
+
+      sig { params(origin_pathname: Pathname, new_package_root: Pathname).returns(Pathname) }
+      def self.destination_pathname_for_package_move(origin_pathname, new_package_root)
+        origin_pack = ParsePackwerk.package_from_path(origin_pathname)
+
+        if origin_pack.name == ParsePackwerk::ROOT_PACKAGE_NAME
+          new_package_root.join(origin_pathname).cleanpath
+        else
+          Pathname.new(origin_pathname.to_s.gsub(origin_pack.name, new_package_root.to_s)).cleanpath
+        end
+      end
+
+      sig { params(origin_pathname: Pathname).returns(Pathname) }
+      def self.destination_pathname_for_new_public_api(origin_pathname)
+        origin_pack = ParsePackwerk.package_from_path(origin_pathname)
+        if origin_pack.name == ParsePackwerk::ROOT_PACKAGE_NAME
+          filepath_without_pack_name = origin_pathname.to_s
+        else
+          filepath_without_pack_name = origin_pathname.to_s.gsub("#{origin_pack.name}/", '')
+        end
+
+        # We join the pack name with the rest of the path...
+        path_parts = filepath_without_pack_name.split('/')
+        Pathname.new(origin_pack.name).join(
+          # ... keeping the "app" or "spec"
+          T.must(path_parts[0]),
+          # ... substituting "controllers," "services," etc. with "public"
+          'public',
+          # ... then the rest is the same
+          T.must(path_parts[2..]).join('/')
+          # and we take the cleanpath so `./app/...` becomes `app/...`
+        ).cleanpath
+      end
+
+      sig { returns(FileMoveOperation) }
+      def spec_file_move_operation
+        # This could probably be implemented by some "strategy pattern" where different extension types are handled by different helpers
+        # Such a thing could also include, for example, when moving a controller, moving its ERB view too.
+        if origin_pathname.extname == '.rake'
+          new_origin_pathname = origin_pathname.sub('/lib/', '/spec/lib/').sub(%r{^lib/}, 'spec/lib/').sub('.rake', '_spec.rb')
+          new_destination_pathname = destination_pathname.sub('/lib/', '/spec/lib/').sub(%r{^lib/}, 'spec/lib/').sub('.rake', '_spec.rb')
+        else
+          new_origin_pathname = origin_pathname.sub('/app/', '/spec/').sub(%r{^app/}, 'spec/').sub('.rb', '_spec.rb')
+          new_destination_pathname = destination_pathname.sub('/app/', '/spec/').sub(%r{^app/}, 'spec/').sub('.rb', '_spec.rb')
+        end
+        FileMoveOperation.new(
+          origin_pathname: new_origin_pathname,
+          destination_pathname: new_destination_pathname,
+          destination_pack: destination_pack
+        )
+      end
+
+      private
+
+      sig { params(path: Pathname).returns(FileMoveOperation) }
+      def relative_to(path)
+        FileMoveOperation.new(
+          origin_pathname: origin_pathname.relative_path_from(path),
+          destination_pathname: destination_pathname.relative_path_from(path),
+          destination_pack: destination_pack
+        )
+      end
+    end
+  end
+end

data/lib/packs/private/interactive_cli/file_selector.rb

@@ -0,0 +1,26 @@
+# typed: strict
+
+module Packs
+  module Private
+    module InteractiveCli
+      class FileSelector
+        extend T::Sig
+
+        sig { params(prompt: TTY::Prompt).returns(T::Array[String]) }
+        def self.select(prompt)
+          prompt.on(:keytab) do
+            raw_paths_relative_to_root = prompt.multiline('Please copy in a space or new line separated list of files or directories')
+            paths_relative_to_root = T.let([], T::Array[String])
+            raw_paths_relative_to_root.each do |path|
+              paths_relative_to_root += path.chomp.split
+            end
+
+            return paths_relative_to_root
+          end
+
+          [prompt.ask('Please input a file or directory to move (press tab to enter multiline mode)')]
+        end
+      end
+    end
+  end
+end