wslc-wip 0.4.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be995c6781c440a7fd84dd3c3bbbddd6799154b59694edce5aa653d80c7d6e53
-  data.tar.gz: 7fb1638a125b2bce92212e8ff525a38e31e2d8aa4386e3e74e379420d4df9c91
+  metadata.gz: c125a123c76462cbb6b78fe0ead5ea400b8fd0f7a8c825421985547190603d02
+  data.tar.gz: 0762dbbf6480a84d9ef58d9481d1398672b5d2ef7e8d644d39be655558704022
 SHA512:
-  metadata.gz: 539721780baa7f366f215581629a761c85e396823e05ff08a3da97c2d0de7808d1470c959240867a5a0ab762f4441ea8b2cb22c92f0063712a18c6b0f80dc4fe
-  data.tar.gz: fc00ceceeeb01cd63ac931ff2ffeea1f64848f38a1222b60b8c5de7a501e914a3820d61abbd7d437ebd412e2046958223edab7b46d582b5cb6ef693badf5cc3e
+  metadata.gz: b91868415f3069167ddd479616d9bd2937d3684af2e7c6228789b198cd7af952e9d2705fe363877ef05a6831a7f5a8e9a203e073623bb0c4b46102f2771429c5
+  data.tar.gz: 88b8d3fdec972776b0bdefedd5753ebcb4a025cb9bf54122ad7eb723e663f4cac64dff5a4ec201bd45b5959b9f44ba6801e8441419ff72f388631eb7eee80f67

data/README.md

@@ -103,6 +103,22 @@ commands:
 credential, or auth. Keep real secrets out of the config file and in your runtime environment
 instead.
 
+### .env
+
+Like `docker compose`, `wip` automatically loads a `.env` file next to `wip.yml` (one `KEY=VALUE`
+per line; `#` comments, blank lines, `export` prefixes, and quoted values are all supported) and
+passes its keys through as container environment variables on `build`, `up`, `run`, `exec`, and
+custom commands. `.env` only fills in keys that aren't already set by `defaults.env` or a
+command/dependency's own `env` — those always win on conflict. Pass `--env-file PATH` to load a
+different file instead.
+
+### .dockerignore
+
+`wip build` reads `.dockerignore` from the build context and stages a filtered copy of the
+context (skipping anything it matches) before handing it to `wslc build`, since `wslc` sends the
+context as-is otherwise. If there's no `.dockerignore`, the original context directory is used
+directly with no copying.
+
 ### Dependency containers
 
 If your app needs sidecar services (a database, Redis, ...), declare them under `dependencies`
@@ -113,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 |
@@ -124,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
@@ -193,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:
@@ -227,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/build_context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+require 'tmpdir'
+
+module Wip
+  # Stages a build context into a scratch directory with anything matched by
+  # .dockerignore left out, since wslc build (unlike `docker build`) sends the
+  # context as-is instead of filtering it itself.
+  class BuildContext
+    def initialize(context, ignore: nil)
+      @root = Pathname(context).expand_path
+      @ignore = ignore || DockerIgnore.load(@root.join('.dockerignore'))
+    end
+
+    def stage
+      return yield @root.to_s if @ignore.empty?
+
+      Dir.mktmpdir('wip-build-context-') do |dir|
+        copy_included_files(Pathname(dir))
+        yield dir
+      end
+    end
+
+    private
+
+    def copy_included_files(destination)
+      each_included_file do |relative_path|
+        target = destination.join(relative_path)
+        FileUtils.mkdir_p(target.dirname)
+        FileUtils.cp(@root.join(relative_path), target)
+      end
+    end
+
+    def each_included_file
+      Dir.glob('**/*', File::FNM_DOTMATCH, base: @root.to_s).each do |entry|
+        next if %w[. ..].include?(entry)
+
+        path = @root.join(entry)
+        next unless path.file?
+        next if @ignore.ignored?(entry)
+
+        yield entry
+      end
+    end
+  end
+end

data/lib/wip/cli.rb

@@ -4,11 +4,13 @@ require 'thor'
 require 'yaml'
 require 'json'
 require 'stringio'
+require 'shellwords'
 
 module Wip
   # Thor-based command-line interface for wip.
   class CLI < Thor
     class_option :config, type: :string, desc: 'Path to wip.yml'
+    class_option :env_file, type: :string, desc: 'Path to a dotenv file (default: .env next to wip.yml)'
     class_option :debug, type: :boolean, default: false, desc: 'Print progress and timing for each step'
     class_option :debug_log, type: :string, desc: 'Where --debug snapshots go: a file path, or "-" for inline'
     default_task :dispatch
@@ -52,12 +54,20 @@ module Wip
     desc 'build [OPTIONS]', 'Build the configured image'
     def build(*extra)
       extra.shift if extra.first == '--'
-      execute(builder.build(settings: load_config.command('build') || {}, extra: extra))
+      settings = load_config.command('build') || {}
+      context = settings['context'] || load_config.defaults['context'] || '.'
+      BuildContext.new(context).stage do |staged_context|
+        execute(builder.build(settings: settings.merge('context' => staged_context), extra: extra))
+      end
     end
 
     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
@@ -65,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|
@@ -76,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
@@ -118,7 +140,41 @@ module Wip
     def loader = ConfigLoader.new(path: options[:config])
     def load_config = (@load_config ||= loader.load)
     def resolver = CommandResolver.new
-    def builder = CommandBuilder.new(wslc: resolver.resolve(load_config.wslc_command), config: load_config)
+
+    def dotenv_path
+      options[:env_file] ? Pathname(options[:env_file]).expand_path : Pathname(load_config.path).dirname.join('.env')
+    end
+
+    def dotenv = @dotenv ||= DotenvLoader.new(dotenv_path).load
+
+    def builder
+      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?)
@@ -174,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_builder.rb

@@ -5,10 +5,11 @@ require 'shellwords'
 module Wip
   # Builds the argument arrays for wslc build/exec/run/custom invocations.
   class CommandBuilder
-    def initialize(wslc:, config:, environment: Environment.new)
+    def initialize(wslc:, config:, environment: Environment.new, dotenv: {})
       @wslc = wslc
       @config = config
       @environment = environment
+      @dotenv = dotenv
     end
 
     def exec(arguments, settings: {}, interactive: true)
@@ -115,7 +116,7 @@ module Wip
     def options(values, include_container: false, include_publish: true)
       result = []
       result.push('-w', values['workdir']) unless values['workdir'].to_s.empty?
-      values.fetch('env', {}).each { |key, value| result.push('-e', "#{key}=#{value}") }
+      merged_env(values).each { |key, value| result.push('-e', "#{key}=#{value}") }
       if include_publish
         Array(values['ports']).each { |port| result.push('-p', port.to_s) }
         Array(values['volumes']).each { |volume| result.push('-v', volume.to_s) }
@@ -124,6 +125,9 @@ module Wip
       result
     end
 
+    # .env supplies defaults; env set in wip.yml (defaults or per-command) wins on conflict.
+    def merged_env(values) = @dotenv.merge(values.fetch('env', {}))
+
     def required(values, key)
       value = values[key]
       raise ConfigError, "Configured #{key} must not be empty" if value.to_s.empty?

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/docker_ignore.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Wip
+  # Parses a .dockerignore file and decides whether a build-context-relative
+  # path should be excluded, following the same pattern rules as the Docker
+  # CLI (gitignore-like globs, later rules override earlier ones, `!` negates).
+  class DockerIgnore
+    Rule = Struct.new(:pattern, :negate)
+
+    FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+    def self.load(path)
+      path = Pathname(path)
+      return new([]) unless path.file?
+
+      new(path.readlines)
+    end
+
+    def initialize(lines)
+      @rules = lines.filter_map { |line| parse(line) }
+    end
+
+    def empty? = @rules.empty?
+
+    def ignored?(relative_path)
+      @rules.reduce(false) do |ignored, rule|
+        matches?(rule.pattern, relative_path) ? !rule.negate : ignored
+      end
+    end
+
+    private
+
+    def parse(line)
+      line = line.strip
+      return nil if line.empty? || line.start_with?('#')
+
+      negate = line.start_with?('!')
+      pattern = negate ? line[1..] : line
+      pattern = pattern.delete_suffix('/')
+      anchored = pattern.start_with?('/')
+      pattern = pattern.delete_prefix('/')
+      pattern = "**/#{pattern}" if !anchored && !pattern.include?('/')
+      Rule.new(pattern, negate)
+    end
+
+    # A match on a directory component also excludes everything under it,
+    # so every prefix of the path (not just the full path) is tested.
+    def matches?(pattern, relative_path)
+      components = relative_path.split('/')
+      (1..components.size).any? do |i|
+        File.fnmatch(pattern, components[0...i].join('/'), FNMATCH_FLAGS)
+      end
+    end
+  end
+end

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/dotenv_loader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Wip
+  # Parses a .env file the way `docker compose` does, so values don't have to
+  # be duplicated into wip.yml just to reach the container as -e flags.
+  class DotenvLoader
+    LINE_PATTERN = /\A(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)\z/
+
+    def initialize(path)
+      @path = Pathname(path)
+    end
+
+    def load
+      return {} unless @path.file?
+
+      @path.readlines.each_with_object({}) do |line, env|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+
+        match = LINE_PATTERN.match(line)
+        next unless match
+
+        env[match[1]] = unquote(match[2])
+      end
+    end
+
+    private
+
+    def unquote(value)
+      value = value.strip
+      return value[1..-2] if value.start_with?('"') && value.end_with?('"') && value.length >= 2
+      return value[1..-2] if value.start_with?("'") && value.end_with?("'") && value.length >= 2
+
+      value.split(/\s+#/, 2).first.to_s.strip
+    end
+  end
+end

data/lib/wip/version.rb

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

data/lib/wip.rb

@@ -5,9 +5,13 @@ require_relative 'wip/errors'
 require_relative 'wip/config'
 require_relative 'wip/config_loader'
 require_relative 'wip/environment'
+require_relative 'wip/dotenv_loader'
+require_relative 'wip/docker_ignore'
+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.4.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Wip contributors
@@ -33,15 +33,19 @@ files:
 - README.md
 - exe/wip
 - lib/wip.rb
+- lib/wip/build_context.rb
 - lib/wip/cli.rb
 - lib/wip/command_builder.rb
 - 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
+- lib/wip/docker_ignore.rb
 - lib/wip/doctor.rb
+- lib/wip/dotenv_loader.rb
 - lib/wip/environment.rb
 - lib/wip/error_interpreter.rb
 - lib/wip/errors.rb