wslc-wip 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0845dfb67f17323b8a99e6f2f92ef06c17bc03fd1316680cf5f43f2640d73da3'
-  data.tar.gz: 6eea9bb520aed0fff5b401b71a20dccdade6b50d9a71403037e59e4e5b83ab2e
+  metadata.gz: c125a123c76462cbb6b78fe0ead5ea400b8fd0f7a8c825421985547190603d02
+  data.tar.gz: 0762dbbf6480a84d9ef58d9481d1398672b5d2ef7e8d644d39be655558704022
 SHA512:
-  metadata.gz: 1b522d206ba3070244f51bda9d4e144dfe95df63ab01bb92b35d0fe0e84a29035c997d7b061c2ec23286c8bd9f586c69e276b7304abd1c8ad81fe808293599b5
-  data.tar.gz: d7fc237820edfcc734f55775e027133c5f9877c24b16f5b1ca6aa98304b35fdea5825a179ff7f64b4d22fe2634d52d11761777284b68a86e76faa56432d33230
+  metadata.gz: b91868415f3069167ddd479616d9bd2937d3684af2e7c6228789b198cd7af952e9d2705fe363877ef05a6831a7f5a8e9a203e073623bb0c4b46102f2771429c5
+  data.tar.gz: 88b8d3fdec972776b0bdefedd5753ebcb4a025cb9bf54122ad7eb723e663f4cac64dff5a4ec201bd45b5959b9f44ba6801e8441419ff72f388631eb7eee80f67

data/README.md

@@ -129,6 +129,47 @@ the same way Compose's service names resolve. `wip down` tears the main containe
 dependencies down (the network itself is left in place). Each dependency entry accepts `image`
 (required), `command`, `env`, `ports`, `volumes`, and `workdir` — the same shape as `defaults`.
 
+### Compose mode
+
+If your project already has a real `compose.yml`, don't duplicate it in `dependencies:` — point
+`wip` at it instead:
+
+```yaml
+version: 1
+compose:
+  service: app             # required: which compose service wip run/exec/NAME target
+  command: wslc-compose    # required: the compose-for-wslc binary/path you have installed
+  file: compose.yml        # optional; auto-detected next to wip.yml otherwise
+  project: myapp            # optional; omitted lets the compose tool pick its own default
+```
+
+`compose:` is mutually exclusive with `dependencies:`/`defaults.network` — pick one orchestration
+path per project. In compose mode, `wip` becomes a thin bridge to an external compose-for-`wslc`
+CLI rather than reimplementing Compose itself.
+
+`wslc` itself has no native Compose support yet (tracked upstream in
+[microsoft/WSL#40948](https://github.com/microsoft/WSL/issues/40948)), and until it does,
+independent third-party tools fill the gap — for example
+[bacarndiaye/wslc-compose](https://github.com/bacarndiaye/wslc-compose) (Python) and
+[inuyume/wslc-compose](https://github.com/inuyume/wslc-compose) (Go), among others. `wslc` is new
+and still evolving, so expect more of these to show up (and existing ones to change) over time.
+`wip` deliberately doesn't pick a winner or default to any of them (unlike `wslc.command`, which
+defaults to `auto` and searches for `wslc.exe`/`wslc`): `compose.command` is required and treats
+every implementation equally — set it to whichever binary name or absolute path you've installed.
+Whichever one you use needs to understand `-f FILE [-p PROJECT] up|down|exec|logs`, the subset of
+the Compose CLI vocabulary `wip` drives. `wip doctor` reports whether the configured command is
+found, its version, and which compose file `wip` resolved.
+
+- `wip up`/`wip down` delegate straight to `<compose command> up -d`/`down`.
+- `wip exec`/`wip NAME` (custom `commands:`) run inside `compose.service`.
+- `wip shell` also goes through the bridge: unless `commands.shell` is defined in `wip.yml`, it
+  `exec`s `bash` against `compose.service`, falling back to `sh`.
+- `wip logs [-f] [SERVICE...]` is only available in compose mode.
+- `wip run` has no ephemeral-container equivalent in this exec-only vocabulary, so it falls back
+  to `exec` against the already-running `compose.service` (wip warns when this happens).
+- `commands:` entries with `type: run`/`type: build` aren't supported in compose mode — use your
+  compose tool's own `build`/`up --build` directly; compose owns builds for its own services.
+
 ## Commands
 
 | Command | Description |
@@ -140,8 +181,9 @@ dependencies down (the network itself is left in place). Each dependency entry a
 | `wip up [-d]` | Start `defaults.container` and its `dependencies` (creating any that are missing, on `defaults.network` if set). `-d` runs the main container in the background |
 | `wip down` | Stop and remove `defaults.container` and its `dependencies` |
 | `wip exec [--no-interactive] COMMAND...` | Run a command in the existing container |
-| `wip run [--no-interactive] COMMAND...` | Run a command in a new `--rm` container |
+| `wip run [--no-interactive] COMMAND...` | Run a command in a new `--rm` container (compose mode: `exec`s into `compose.service` instead) |
 | `wip shell` | Open the configured shell, falling back to `bash` then `sh` |
+| `wip logs [-f] [SERVICE...]` | Follow compose service logs (compose mode only) |
 | `wip NAME ARGS...` | Run `commands.NAME`, appending any extra arguments |
 
 TTY allocation is decided by combining the command's config, the CLI option, and whether both
@@ -209,6 +251,23 @@ When `pull access denied` (or similar) is detected, wip suggests how to log in:
 wslc registry login -u <username> docker.io
 ```
 
+### Slow boot when the app directory is bind-mounted
+
+wslc containers run in their own VM, so a bind-mounted host directory (`.:/app`) is always shared
+in over virtiofs, even when the host path is already on WSL's native filesystem. Frameworks that
+scan large directory trees at startup (Ruby's Zeitwerk autoloader, for example) issue many small
+per-file stat/open calls, and each one is a round trip through that layer — CPU on the Windows
+side can look busy while almost no data is actually transferred, and the process can appear hung
+for minutes with barely any resource usage to show for it.
+
+If a debug log shows a boot-time command "stuck" with low CPU/mem/IO in `resource_monitor`'s
+output, this is worth checking before assuming the app itself is broken. The workaround is to stop
+bind-mounting the source live and instead mirror it into a named volume: mount the host path
+read-only (`.:/host-src:ro`), add a named volume for `/app`, and have the container's entrypoint
+`rsync` from the read-only mount into the volume before boot, then keep syncing in the background
+(e.g. every couple of seconds) so edits still show up with a short delay. The app then only ever
+touches fast native storage once it's running.
+
 ### CPU architecture mismatch
 
 Check the image and publish a multi-arch (amd64/arm64) image:
@@ -243,10 +302,42 @@ checklist.
 
 ## Not in the initial release
 
-Full Compose compatibility (multiple networks, `depends_on` ordering/health checks, profiles), a
-resident/daemon process, a GUI, PowerShell-specific tuning, direct registry API/manifest parsing,
-self-update, and plugins are all unimplemented. Likely future additions: a richer config schema,
-lifecycle hooks, platform selection, and more detailed diagnostics.
+Full Compose compatibility isn't reimplemented in `wip` itself, but is available by delegating to
+a third-party compose-for-`wslc` tool — see [Compose mode](#compose-mode). A resident/daemon
+process, a GUI, PowerShell-specific tuning, direct registry API/manifest parsing, self-update, and
+plugins are all unimplemented.
+
+## Roadmap
+
+`wip` already covers most of what [`dip`](https://github.com/bibendi/dip) adds on top of Compose —
+named commands (`commands:`), `run`/`exec` hidden behind a single verb, `.env` passthrough, and
+sidecar services via `dependencies:` + `defaults.network`. Fuller Compose semantics
+(`depends_on` ordering/health checks, log aggregation, named volumes, profiles, scaling) are now
+handled by delegating to a separate compose-for-`wslc` tool in [compose mode](#compose-mode)
+rather than being reimplemented in `wip` itself. Which of those actually work is entirely up to
+the external tool you point `compose.command` at — `wip` only forwards
+`-f FILE [-p PROJECT] up|down|exec|logs`, so treat that list as what Compose offers, not as
+something `wip` guarantees. See that section for what compose mode covers
+and its current limitations (`run`, and `commands:` of type `run`/`build`). What's still planned
+for `wip`, roughly in priority order:
+
+1. **`wip provision`** — a dip-style one-shot bootstrap hook (build → up deps → install deps →
+   create/migrate/seed DB) so a new contributor can go from `git clone` to a working environment
+   in two commands (`wip provision && wip up`).
+2. **Config file merging** — `--config` currently accepts one file; support layering
+   (`wip.yml` + `wip.override.yml`, or a `WIP_CONFIG` list) for dev/CI/debug variants without
+   duplicating the whole file, plus a `wip config --resolved` view of the merged result.
+3. **Bind-mount boot time (`rails c`, `bundle`, ...)** — commands like `wip rails c` still start
+   noticeably slower than the equivalent under `docker compose`, mostly from WSL2 bind-mounted
+   (`.:/app`-style) volumes doing many small reads for gems/`node_modules` (use `--debug` to
+   confirm it's disk I/O and not `wip`'s own overhead). This isn't really `wip`'s responsibility —
+   the fix has to come from either the mount layer or the project's own volume layout. We're also
+   hoping for improvements on the `wslc` side itself (faster bind-mount/cache behavior); `wip`
+   will pick those up for free as soon as they land.
+
+Each of these should stay additive to the existing `wip.yml` shape — no breaking changes to
+`defaults`, `commands`, `dependencies`, or `compose` are planned. A resident daemon and a GUI
+remain out of scope; see "Not in the initial release" above.
 
 ## License
 

data/lib/wip/cli.rb

@@ -4,6 +4,7 @@ require 'thor'
 require 'yaml'
 require 'json'
 require 'stringio'
+require 'shellwords'
 
 module Wip
   # Thor-based command-line interface for wip.
@@ -63,6 +64,10 @@ module Wip
     desc 'up', 'Start the configured container and its dependencies, creating them if necessary'
     option :detach, type: :boolean, default: false, aliases: '-d'
     def up
+      if load_config.compose?
+        return execute(compose_bridge.up(detach: options[:detach]), interactive: tty?(!options[:detach]))
+      end
+
       ensure_network
       load_config.dependencies.each_key { |name| ensure_dependency(name) }
       ensure_container
@@ -70,6 +75,8 @@ module Wip
 
     desc 'down', 'Stop and remove the configured container and its dependencies'
     def down
+      return execute(compose_bridge.down, exit_on_failure: false) if load_config.compose?
+
       execute(builder.down, exit_on_failure: false)
       execute(builder.remove, exit_on_failure: false)
       load_config.dependencies.each_key do |name|
@@ -81,41 +88,51 @@ module Wip
     desc 'exec COMMAND...', 'Execute a command in the running container'
     option :interactive, type: :boolean, default: true
     def exec(*command)
-      tty = builder.tty?(options[:interactive])
-      execute(builder.exec(command, interactive: options[:interactive]), interactive: tty)
+      execute(exec_target(command, interactive: options[:interactive]), interactive: tty?(options[:interactive]))
     end
 
     desc 'run COMMAND...', 'Run a command in a new container'
     option :interactive, type: :boolean, default: true
     def run_command(*command)
-      tty = builder.tty?(options[:interactive])
-      execute(builder.run(command, interactive: options[:interactive]), interactive: tty)
+      if load_config.compose?
+        warn "wip: compose mode has no ephemeral 'run'; executing in the running " \
+             "'#{load_config.compose_service}' service instead"
+        return execute(exec_target(command, interactive: options[:interactive]),
+                       interactive: tty?(options[:interactive]))
+      end
+
+      execute(builder.run(command, interactive: options[:interactive]), interactive: tty?(options[:interactive]))
     end
     map 'run' => :run_command
 
     desc 'shell', 'Open a shell in the configured container'
     def shell_command
       configured = load_config.command('shell')
-      if configured
-        tty = builder.tty?(configured.fetch('interactive', false))
-        return execute(builder.custom('shell', []), interactive: tty)
-      end
+      return dispatch('shell') if configured
 
-      tty = builder.tty?(true)
-      code = execute(builder.exec(['bash'], settings: { 'interactive' => true }, interactive: true),
-                     interactive: tty, exit_on_failure: false)
+      code = execute(exec_target(['bash'], interactive: true), interactive: tty?(true), exit_on_failure: false)
       return if code.zero?
 
-      execute(builder.exec(['sh'], settings: { 'interactive' => true }, interactive: true), interactive: tty)
+      execute(exec_target(['sh'], interactive: true), interactive: tty?(true))
     end
     map 'shell' => :shell_command
 
+    desc 'logs [SERVICE...]', 'Follow logs from compose services (compose mode only)'
+    option :follow, type: :boolean, default: true, aliases: '-f'
+    def logs(*services)
+      raise ConfigError, '`wip logs` is only available in compose mode' unless load_config.compose?
+
+      execute(compose_bridge.logs(services: services, follow: options[:follow]), interactive: true)
+    end
+
     desc 'dispatch COMMAND [ARGS...]', 'Run a command defined in wip.yml'
     def dispatch(name = nil, *arguments)
       raise ConfigError, 'A command is required' unless name
 
       values = load_config.command(name) || raise(ConfigError, "Unknown command: #{name}")
-      execute(builder.custom(name, arguments), interactive: builder.tty?(values.fetch('interactive', false)))
+      return dispatch_compose(name, values, arguments) if load_config.compose?
+
+      execute(builder.custom(name, arguments), interactive: tty?(values.fetch('interactive', false)))
     end
 
     private
@@ -134,6 +151,31 @@ module Wip
       CommandBuilder.new(wslc: resolver.resolve(load_config.wslc_command), config: load_config, dotenv: dotenv)
     end
 
+    def compose_bridge = @compose_bridge ||= ComposeBridge.for(load_config)
+
+    def tty?(requested) = requested && Environment.new.interactive?
+
+    def exec_target(arguments, interactive:)
+      if load_config.compose?
+        return compose_bridge.exec(load_config.compose_service, arguments,
+                                   interactive: interactive)
+      end
+
+      builder.exec(arguments, interactive: interactive)
+    end
+
+    def dispatch_compose(name, values, arguments)
+      type = values['type'] || 'exec'
+      unless type == 'exec'
+        raise ConfigError, "commands.#{name}: type '#{type}' is not supported in compose mode " \
+                           '(use `wslc-compose build`/`up --build` directly)'
+      end
+
+      command = Shellwords.split(values['command'].to_s) + arguments
+      interactive = values.fetch('interactive', false)
+      execute(exec_target(command, interactive: interactive), interactive: tty?(interactive))
+    end
+
     def execute(command, interactive: false, exit_on_failure: true)
       runner = CommandRunner.new(debug: debug?)
       code = reporter.step("running: #{CommandDisplay.for_debug(command)}", live: !interactive) do
@@ -188,7 +230,7 @@ module Wip
 
     def ensure_container
       container = load_config.defaults['container']
-      interactive = builder.tty?(!options[:detach])
+      interactive = tty?(!options[:detach])
       if resource_exists?(builder.find)
         warn "wip: starting existing container '#{container}'"
         execute(builder.start(detach: options[:detach]), interactive: interactive)

data/lib/wip/command_resolver.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
 
 module Wip
-  # Locates the wslc/wslc.exe executable on the current system.
+  # Locates an executable on the current system, trying a list of candidates.
   class CommandResolver
     CANDIDATES = ['wslc.exe', 'wslc', '/mnt/c/Windows/System32/wslc.exe'].freeze
+    DEFAULT_INSTALL_HINT = <<~HINT.chomp
+      Install or update the WSL container tooling, then run:
 
-    def initialize(path: ENV.fetch('PATH', ''), executable: nil)
+        wip doctor
+    HINT
+
+    def initialize(path: ENV.fetch('PATH', ''), executable: nil, candidates: CANDIDATES, label: 'WSLC',
+                   install_hint: DEFAULT_INSTALL_HINT)
       @path = path
       @executable = executable || method(:executable?)
+      @candidates = candidates
+      @label = label
+      @install_hint = install_hint
     end
 
     def resolve(configured = 'auto')
       return configured if configured != 'auto' && @executable.call(configured)
-      return raise_not_found if configured != 'auto'
+      return raise_not_found([configured]) if configured != 'auto'
 
-      CANDIDATES.find { |candidate| @executable.call(candidate) } || raise_not_found
+      @candidates.find { |candidate| @executable.call(candidate) } || raise_not_found(@candidates)
     end
 
     private
@@ -25,16 +34,14 @@ module Wip
       @path.split(File::PATH_SEPARATOR).any? { |directory| File.executable?(File.join(directory, command)) }
     end
 
-    def raise_not_found
+    def raise_not_found(attempted)
       raise CommandNotFoundError, <<~MESSAGE
-        WSLC was not found.
+        #{@label} was not found.
 
         Checked:
-          #{CANDIDATES.join("\n  ")}
-
-        Install or update the WSL container tooling, then run:
+          #{attempted.join("\n  ")}
 
-          wip doctor
+        #{@install_hint}
       MESSAGE
     end
   end

data/lib/wip/compose_bridge.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Wip
+  # Builds argument arrays for wslc-compose invocations, delegating orchestration
+  # to a real compose.yml instead of wip's own dependencies:/network handling.
+  class ComposeBridge
+    FILENAMES = %w[compose.yml compose.yaml docker-compose.yml docker-compose.yaml].freeze
+    # No default candidates: wip doesn't favor any one compose-for-wslc implementation.
+    # compose.command must name the one you've installed.
+    INSTALL_HINT = <<~HINT.chomp
+      wip doesn't bundle or pin a compose-for-wslc implementation — install one and set
+      compose.command in wip.yml to its binary name or path, e.g.:
+
+        https://github.com/bacarndiaye/wslc-compose
+        https://github.com/inuyume/wslc-compose
+    HINT
+
+    def self.for(config, resolver: CommandResolver.new(candidates: [], label: 'compose command',
+                                                       install_hint: INSTALL_HINT))
+      new(compose_command: resolver.resolve(config.compose_command), file: file_path(config),
+          project: config.compose_project)
+    end
+
+    def self.file_path(config)
+      base = Pathname(config.path).dirname
+      configured = config.compose_file
+      # Relative compose.file is resolved against wip.yml, not the current directory,
+      # so `wip` behaves the same from any subdirectory (matching auto-detection below).
+      return base.join(configured).expand_path if configured
+
+      FILENAMES.map { |name| base.join(name) }.find(&:file?) ||
+        raise(ConfigError, "compose mode: no compose file found next to #{config.path} " \
+                           "(looked for #{FILENAMES.join(', ')})")
+    end
+
+    def initialize(compose_command:, file:, project: nil)
+      @compose_command = compose_command
+      @file = file
+      @project = project
+    end
+
+    def up(detach: true)
+      command = base.push('up')
+      command << '-d' if detach
+      command
+    end
+
+    def down = base.push('down')
+
+    def exec(service, arguments, interactive: true)
+      command = base.push('exec')
+      command << '-T' unless interactive
+      command.push(service.to_s).concat(arguments)
+    end
+
+    def logs(services: [], follow: true)
+      command = base.push('logs')
+      command << '-f' if follow
+      command.concat(services.map(&:to_s))
+    end
+
+    private
+
+    def base
+      command = [@compose_command, '-f', @file.to_s]
+      command.push('-p', @project) if @project
+      command
+    end
+  end
+end

data/lib/wip/config.rb

@@ -20,6 +20,12 @@ module Wip
     def up_command = @raw.dig('up', 'command')
     def dependencies = @raw['dependencies'] || {}
     def network = defaults['network']
+    def compose = @raw['compose']
+    def compose? = !!compose
+    def compose_service = compose && compose['service']
+    def compose_file = compose && compose['file']
+    def compose_project = compose && compose['project']
+    def compose_command = compose && compose['command']
 
     def command(name)
       entry = commands[name.to_s]
@@ -37,7 +43,7 @@ module Wip
 
     def to_h(redact: true)
       value = { 'version' => 1, 'wslc' => { 'command' => wslc_command }, 'defaults' => defaults,
-                'up' => { 'command' => up_command }, 'dependencies' => dependencies,
+                'up' => { 'command' => up_command }, 'dependencies' => dependencies, 'compose' => compose,
                 'commands' => commands.transform_values { |entry| defaults.merge('type' => 'exec').merge(entry) } }
       redact ? redact_secrets(value) : value
     end
@@ -50,6 +56,7 @@ module Wip
 
       validate_commands!
       validate_dependencies!
+      validate_compose!
     end
 
     def validate_commands!
@@ -64,6 +71,15 @@ module Wip
       dependencies.each { |name, entry| validate_dependency!(name, entry) }
     end
 
+    def validate_compose!
+      return unless @raw.key?('compose')
+      raise ConfigError, 'compose must be a mapping' unless compose.is_a?(Hash)
+      raise ConfigError, 'compose.service must not be empty' if compose_service.to_s.empty?
+      raise ConfigError, 'compose.command must not be empty' if compose_command.to_s.empty?
+      raise ConfigError, 'compose is mutually exclusive with dependencies' if dependencies.any?
+      raise ConfigError, 'compose is mutually exclusive with defaults.network' if network
+    end
+
     def validate_command!(name, entry)
       raise ConfigError, "commands.#{name} must be a mapping" unless entry.is_a?(Hash)
 

data/lib/wip/doctor.rb

@@ -7,10 +7,13 @@ module Wip
   class Doctor
     Result = Data.define(:level, :message)
 
-    def initialize(loader:, resolver: CommandResolver.new, environment: Environment.new)
+    def initialize(loader:, resolver: CommandResolver.new, environment: Environment.new,
+                   compose_resolver: CommandResolver.new(candidates: [], label: 'compose command',
+                                                         install_hint: ComposeBridge::INSTALL_HINT))
       @loader = loader
       @resolver = resolver
       @environment = environment
+      @compose_resolver = compose_resolver
     end
 
     def call
@@ -19,8 +22,8 @@ module Wip
       results << interop_result unless @environment.windows?
       results << Result.new(:ok, "Architecture: #{@environment.architecture}")
       config = load_config(results)
-      command = resolve(config, results) if config
-      check_version(command, results) if command
+      check_wslc(config, results) if config
+      check_compose(config, results) if config&.compose?
       results << result(command_available?('git') ? :ok : :warn, 'Git is available',
                         'Git is not available to the WSLC build environment')
       results
@@ -41,7 +44,7 @@ module Wip
 
     def load_config(results)
       config = @loader.load
-      invalid = %w[container image].select { |key| config.defaults[key].to_s.empty? }
+      invalid = config.compose? ? [] : %w[container image].select { |key| config.defaults[key].to_s.empty? }
       results << Result.new(invalid.empty? ? :ok : :fail,
                             invalid.empty? ? 'Loaded wip.yml' : "Empty defaults: #{invalid.join(', ')}")
       config
@@ -50,6 +53,11 @@ module Wip
       nil
     end
 
+    def check_wslc(config, results)
+      command = resolve(config, results)
+      check_version(command, results) if command
+    end
+
     def resolve(config, results)
       command = @resolver.resolve(config.wslc_command)
       results << Result.new(:ok, "Found #{command}")
@@ -59,12 +67,35 @@ module Wip
       nil
     end
 
-    def check_version(command, results)
+    def check_version(command, results, label: 'WSLC')
       _output, status = Open3.capture2e(command, 'version')
       results << Result.new(status.success? ? :ok : :fail,
-                            status.success? ? 'WSLC is available' : 'WSLC version failed')
+                            status.success? ? "#{label} is available" : "#{label} version failed")
     rescue Errno::ENOENT
-      results << Result.new(:fail, 'WSLC version failed')
+      results << Result.new(:fail, "#{label} version failed")
+    end
+
+    def check_compose(config, results)
+      command = resolve_compose(config, results)
+      check_version(command, results, label: 'compose command') if command
+      check_compose_file(config, results)
+    end
+
+    def resolve_compose(config, results)
+      command = @compose_resolver.resolve(config.compose_command)
+      results << Result.new(:ok, "Found #{command}")
+      command
+    rescue CommandNotFoundError => e
+      results << Result.new(:fail, e.message)
+      nil
+    end
+
+    def check_compose_file(config, results)
+      path = ComposeBridge.file_path(config)
+      results << result(path.file? ? :ok : :fail, "Found compose file #{path}",
+                        "Compose file not found: #{path}")
+    rescue ConfigError => e
+      results << Result.new(:fail, e.message)
     end
 
     def result(condition, ok_message, fail_message)

data/lib/wip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wip
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/wip.rb

@@ -11,6 +11,7 @@ require_relative 'wip/build_context'
 require_relative 'wip/command_resolver'
 require_relative 'wip/error_interpreter'
 require_relative 'wip/command_builder'
+require_relative 'wip/compose_bridge'
 require_relative 'wip/command_display'
 require_relative 'wip/command_runner'
 require_relative 'wip/resource_monitor'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wslc-wip
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Wip contributors
@@ -39,6 +39,7 @@ files:
 - lib/wip/command_display.rb
 - lib/wip/command_resolver.rb
 - lib/wip/command_runner.rb
+- lib/wip/compose_bridge.rb
 - lib/wip/config.rb
 - lib/wip/config_loader.rb
 - lib/wip/debug_reporter.rb