wslc-wip 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8e5f43bc1610d2c7af26c4ed9052ca4a055bcbbc97957f756452b5992b020b3
+  data.tar.gz: 24299f3953026ccde81f3bc485234769aa417bac0bc6a22ab37c82ce76d1c8ac
+SHA512:
+  metadata.gz: 643895970056693e00703eddbecb9303fafd798bfe1f2ea005435f5b6daf36678e687784a75105fb88dbc01ca524060d4a9b8862ab3b38fce8121a577bcd868f
+  data.tar.gz: 0542772f24b25763b610aba4d940f589bae73327f444103d77e9c899b6376f73ffcb78ce6a56c91fd180a5c1ac053e0ea8e5269008919d19541036d7d0550aa0

data/LICENSE

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

data/README.md

@@ -0,0 +1,141 @@
+# wip
+
+`wip` は、Docker 開発環境 CLI の dip に近い操作感を Microsoft WSLC に提供する Ruby 製 OSS CLI ラッパーです。プロジェクト固有のコンテナ、イメージ、環境変数やコマンドを `wip.yml` にまとめ、安全な引数配列として `wslc.exe` / `wslc` に渡します。
+
+> **Status:** 初期リリース 0.1.0。WSLC 自体の仕様変更に追随が必要になる可能性があります。
+
+## 対応環境とインストール
+
+Ruby 3.2 以上、WSL2、および Microsoft WSLC が必要です。RubyGems 公開後は次で導入できます。
+
+```bash
+gem install wip
+```
+
+ソースからは `bundle install && bundle exec exe/wip version` を使用します。
+
+## クイックスタート
+
+```bash
+gem install wip
+cd my-project
+wip doctor
+wip build
+wip rails console
+```
+
+## 完全な設定例
+
+プロジェクトルートに `wip.yml` を置きます。子ディレクトリから実行しても親方向へ探索され、`--config PATH` で明示指定もできます。
+
+```yaml
+version: 1
+wslc:
+  command: auto # wslc.exe、wslc、System32 の順。絶対パスも指定可能
+defaults:
+  container: app
+  image: slidict/slidict:development
+  workdir: /app
+  interactive: false
+  remove: true
+  env:
+    RAILS_ENV: development
+    PORT: "3000"
+  ports:
+    - "3000:3000"
+  volumes:
+    - ".:/app"
+commands:
+  rails:
+    type: exec
+    command: bin/rails
+    container: app
+    interactive: true
+    workdir: /app
+    env:
+      RAILS_ENV: development
+  bundle:
+    command: bundle
+  rspec:
+    command: bundle exec rspec
+  shell:
+    command: bash
+    interactive: true
+  migrate:
+    type: run
+    command: bundle exec rails db:migrate
+    image: slidict/slidict:development
+    remove: true
+  build:
+    type: build
+    context: .
+    tag: slidict/slidict:development
+```
+
+`env` の値は文字列化されます。`config` の表示では token、password、secret、credential、auth を含むキーを伏せます。秘密値は可能なら設定ファイルではなく実行環境側で管理してください。
+
+## コマンド
+
+| コマンド | 説明 |
+|---|---|
+| `wip version` | wip と、検出できた WSLC のバージョン |
+| `wip doctor` | WSL2、相互運用、WSLC、設定、アーキテクチャ、Git を診断 |
+| `wip config` | デフォルト適用済み設定（秘密値をマスク） |
+| `wip build -- --no-cache` | build 定義でイメージをビルド |
+| `wip exec [--no-interactive] COMMAND...` | 既存コンテナ内で実行 |
+| `wip run [--no-interactive] COMMAND...` | `--rm` の新規コンテナで実行 |
+| `wip shell` | 定義済み shell、または `bash`、`sh` の順に起動 |
+| `wip NAME ARGS...` | `commands.NAME` を実行し、引数を末尾に追加 |
+
+TTY はコマンド設定、CLI オプション、標準入出力が双方 TTY かを合わせて判定します。`WIP_DEBUG=1` では `Shellwords.join` した実行コマンドを表示します。
+
+## doctor
+
+`[OK]`、`[WARN]`、`[FAIL]` で各診断を表示します。警告だけなら終了コード 0、WSL2/相互運用/WSLC/設定など実行を妨げる問題があれば 1 です。実際のビルド環境から Git が見えない場合は警告になります。
+
+## よくあるエラー
+
+### WSLC がない
+
+WSLC/WSL コンテナツールをインストールまたは更新し、`wip doctor` を実行してください。`auto` は `wslc.exe`、`wslc`、`/mnt/c/Windows/System32/wslc.exe` の順で探します。
+
+### Docker Hub の認証
+
+`pull access denied` 等を検出するとログイン方法を補足します。
+
+```bash
+wslc registry login -u <username> docker.io
+```
+
+### CPU アーキテクチャ不一致
+
+イメージを確認し、amd64/arm64 のマルチアーキテクチャイメージを公開します。
+
+```bash
+docker buildx imagetools inspect <image>
+docker buildx build \
+  --platform linux/amd64,linux/arm64 \
+  -t <image> \
+  --push .
+```
+
+## 開発
+
+```bash
+git clone <repository-url>
+cd wip
+bundle install
+bundle exec rspec
+bundle exec rubocop
+bundle exec rake
+```
+
+テストは WSLC を必要とせず、解決・構築・実行層を差し替え可能にしています。GitHub Actions は Ruby 3.2、3.3、3.4 で RSpec と RuboCop を実行します。
+
+## 初期リリースに含まれないもの
+
+Compose 互換、常駐プロセス、GUI、PowerShell 最適化、レジストリ API/manifest の直接解析、自動更新、プラグインは未実装です。将来は設定スキーマ、ライフサイクルフック、複数コンテナ、プラットフォーム選択、より詳細な診断の追加が有用です。
+
+## License
+
+[MIT License](LICENSE)

data/exe/wip

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'wip'
+
+begin
+  Wip::CLI.start(ARGV)
+rescue Wip::Error => e
+  warn "wip: #{e.message}"
+  exit 1
+end

data/lib/wip/cli.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'yaml'
+
+module Wip
+  # Thor-based command-line interface for wip.
+  class CLI < Thor
+    class_option :config, type: :string, desc: 'Path to wip.yml'
+    default_task :dispatch
+
+    desc 'version', 'Show wip and WSLC versions'
+    def version
+      puts "wip #{VERSION}"
+      config = load_config
+      command = resolver.resolve(config.wslc_command)
+      system(command, 'version')
+    rescue Error
+      nil
+    end
+
+    desc 'doctor', 'Diagnose the development environment'
+    def doctor
+      results = Doctor.new(loader: loader).call
+      results.each { |item| puts "[#{item.level.to_s.upcase}] #{item.message}" }
+      exit(1) if results.any? { |item| item.level == :fail }
+    end
+
+    desc 'config', 'Print the effective configuration'
+    def config
+      puts YAML.dump(load_config.to_h)
+    end
+
+    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))
+    end
+
+    desc 'exec COMMAND...', 'Execute a command in the running container'
+    option :interactive, type: :boolean, default: true
+    def exec(*command)
+      execute(builder.exec(command, interactive: options[:interactive]))
+    end
+
+    desc 'run COMMAND...', 'Run a command in a new container'
+    option :interactive, type: :boolean, default: true
+    def run_command(*command)
+      execute(builder.run(command, interactive: options[:interactive]))
+    end
+    map 'run' => :run_command
+
+    desc 'shell', 'Open a shell in the configured container'
+    def shell_command
+      configured = load_config.command('shell')
+      return execute(builder.custom('shell', [])) if configured
+
+      code = execute(builder.exec(['bash'], settings: { 'interactive' => true }, interactive: true))
+      execute(builder.exec(['sh'], settings: { 'interactive' => true }, interactive: true)) if code != 0
+    end
+    map 'shell' => :shell_command
+
+    desc 'dispatch COMMAND [ARGS...]', 'Run a command defined in wip.yml'
+    def dispatch(name = nil, *arguments)
+      raise ConfigError, 'A command is required' unless name
+
+      execute(builder.custom(name, arguments))
+    end
+
+    private
+
+    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 execute(command)
+      code = CommandRunner.new.run(command)
+      exit(code) unless code.zero?
+      code
+    end
+  end
+end

data/lib/wip/command_builder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Wip
+  # Builds the argument arrays for wslc build/exec/run/custom invocations.
+  class CommandBuilder
+    def initialize(wslc:, config:, environment: Environment.new)
+      @wslc = wslc
+      @config = config
+      @environment = environment
+    end
+
+    def exec(arguments, settings: {}, interactive: true)
+      values = @config.defaults.merge(settings)
+      command = [@wslc, 'exec']
+      command << '-it' if tty?(interactive)
+      command.concat(options(values, include_container: true)).concat(arguments)
+    end
+
+    def run(arguments, settings: {}, interactive: true)
+      values = @config.defaults.merge(settings)
+      command = [@wslc, 'run']
+      command << '--rm' if values['remove']
+      command << '-it' if tty?(interactive)
+      command.concat(options(values)).push(required(values, 'image')).concat(arguments)
+    end
+
+    def build(settings:, extra: [])
+      values = @config.defaults.merge(settings)
+      context = values['context'] || '.'
+      tag = values['tag'] || values['image']
+      raise ConfigError, 'Build image/tag must not be empty' if tag.to_s.empty?
+
+      [@wslc, 'build', '-t', tag, *extra, context]
+    end
+
+    def custom(name, arguments)
+      values = @config.command(name) || raise(ConfigError, "Unknown command: #{name}")
+      type = values['type'] || (name.to_s == 'build' ? 'build' : 'exec')
+      base = Shellwords.split(values['command'].to_s)
+      return build(settings: values, extra: arguments) if type == 'build'
+
+      public_send(type, base + arguments, settings: values, interactive: values.fetch('interactive', false))
+    end
+
+    private
+
+    def options(values, include_container: false)
+      result = []
+      result.push('-w', values['workdir']) unless values['workdir'].to_s.empty?
+      values.fetch('env', {}).each { |key, value| result.push('-e', "#{key}=#{value}") }
+      Array(values['ports']).each { |port| result.push('-p', port.to_s) }
+      Array(values['volumes']).each { |volume| result.push('-v', volume.to_s) }
+      result << required(values, 'container') if include_container
+      result
+    end
+
+    def required(values, key)
+      value = values[key]
+      raise ConfigError, "Configured #{key} must not be empty" if value.to_s.empty?
+
+      value
+    end
+
+    def tty?(requested) = requested && @environment.interactive?
+  end
+end

data/lib/wip/command_resolver.rb

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

data/lib/wip/command_runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+module Wip
+  # Executes a built command, pumping its I/O and returning the exit status.
+  class CommandRunner
+    def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr, interpreter: ErrorInterpreter.new)
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @interpreter = interpreter
+    end
+
+    def run(command, env: {})
+      @stderr.puts "+ #{Shellwords.join(command)}" if ENV['WIP_DEBUG']
+      captured = +''
+      status = nil
+      Open3.popen3(env, *command) do |input, output, error, wait|
+        input.close
+        threads = [pump(output, @stdout, captured), pump(error, @stderr, captured)]
+        threads.each(&:join)
+        status = wait.value
+      end
+      hint = @interpreter.interpret(captured)
+      @stderr.puts("\n#{hint}") if !status.success? && hint
+      status.exitstatus
+    rescue Errno::ENOENT => e
+      @stderr.puts e.message
+      127
+    end
+
+    private
+
+    def pump(source, destination, captured)
+      Thread.new do
+        source.each(4096) do |chunk|
+          destination.write(chunk)
+          captured << chunk
+        end
+      end
+    end
+  end
+end

data/lib/wip/config.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wip
+  # Validated, defaulted access to a parsed wip.yml document.
+  class Config
+    DEFAULTS = { 'container' => 'app', 'workdir' => '/app', 'interactive' => false,
+                 'remove' => true, 'env' => {}, 'ports' => [], 'volumes' => [] }.freeze
+    SECRET_PATTERN = /token|password|secret|credential|auth/i
+    attr_reader :path
+
+    def initialize(raw, path = nil)
+      @raw = stringify(raw)
+      @path = path
+      validate!
+    end
+
+    def wslc_command = @raw.dig('wslc', 'command') || 'auto'
+    def commands = @raw['commands'] || {}
+    def defaults = DEFAULTS.merge(@raw['defaults'] || {})
+
+    def command(name)
+      entry = commands[name.to_s]
+      return unless entry
+
+      defaults.merge('type' => 'exec').merge(entry)
+    end
+
+    def to_h(redact: true)
+      value = { 'version' => 1, 'wslc' => { 'command' => wslc_command }, 'defaults' => defaults,
+                'commands' => commands.transform_values { |entry| defaults.merge('type' => 'exec').merge(entry) } }
+      redact ? redact_secrets(value) : value
+    end
+
+    private
+
+    def validate!
+      raise ConfigError, "Unsupported configuration version: #{@raw['version']}" unless (@raw['version'] || 1) == 1
+      raise ConfigError, 'commands must be a mapping' unless commands.is_a?(Hash)
+
+      commands.each { |name, entry| validate_command!(name, entry) }
+    end
+
+    def validate_command!(name, entry)
+      raise ConfigError, "commands.#{name} must be a mapping" unless entry.is_a?(Hash)
+
+      type = entry['type'] || (name == 'build' ? 'build' : 'exec')
+      raise ConfigError, "Invalid command type for #{name}: #{type}" unless %w[exec run build].include?(type)
+
+      entry['env']&.transform_values!(&:to_s)
+    end
+
+    def stringify(object)
+      case object
+      when Hash then object.to_h { |key, value| [key.to_s, stringify(value)] }
+      when Array then object.map { |value| stringify(value) }
+      else object
+      end
+    end
+
+    def redact_secrets(object)
+      return object.map { |item| redact_secrets(item) } if object.is_a?(Array)
+      return object unless object.is_a?(Hash)
+
+      object.to_h { |key, value| [key, key.match?(SECRET_PATTERN) ? '[REDACTED]' : redact_secrets(value)] }
+    end
+  end
+end

data/lib/wip/config_loader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+
+module Wip
+  # Finds and parses wip.yml, searching parent directories when unset.
+  class ConfigLoader
+    FILENAME = 'wip.yml'
+
+    def initialize(start_dir: Dir.pwd, path: nil)
+      @start_dir = Pathname(start_dir).expand_path
+      @path = path
+    end
+
+    def find
+      return Pathname(@path).expand_path if @path
+
+      @start_dir.ascend do |directory|
+        candidate = directory.join(FILENAME)
+        return candidate if candidate.file?
+      end
+      nil
+    end
+
+    def load
+      path = find
+      raise ConfigError, "wip.yml was not found (searched from #{@start_dir} to the filesystem root)" unless path&.file?
+
+      data = YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
+      Config.new(data, path)
+    rescue Psych::Exception => e
+      raise ConfigError, "Could not parse #{path}: #{e.message}"
+    end
+  end
+end

data/lib/wip/doctor.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Wip
+  # Runs environment diagnostics and reports pass/warn/fail results.
+  class Doctor
+    Result = Data.define(:level, :message)
+
+    def initialize(loader:, resolver: CommandResolver.new, environment: Environment.new)
+      @loader = loader
+      @resolver = resolver
+      @environment = environment
+    end
+
+    def call
+      results = []
+      results << result(@environment.wsl2? ? :ok : :fail, 'Running on WSL2', 'Not running on WSL2')
+      results << result(@environment.windows_interop? ? :ok : :fail, 'Windows executable interoperability is enabled',
+                        'Windows executable interoperability is disabled')
+      results << Result.new(:ok, "Architecture: #{@environment.architecture}")
+      config = load_config(results)
+      command = resolve(config, results) if config
+      check_version(command, results) if command
+      results << result(command_available?('git') ? :ok : :warn, 'Git is available',
+                        'Git is not available to the WSLC build environment')
+      results
+    end
+
+    private
+
+    def load_config(results)
+      config = @loader.load
+      invalid = %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
+    rescue ConfigError => e
+      results << Result.new(:fail, e.message)
+      nil
+    end
+
+    def resolve(config, results)
+      command = @resolver.resolve(config.wslc_command)
+      results << Result.new(:ok, "Found #{command}")
+      command
+    rescue CommandNotFoundError => e
+      results << Result.new(:fail, e.message)
+      nil
+    end
+
+    def check_version(command, results)
+      _output, status = Open3.capture2e(command, 'version')
+      results << Result.new(status.success? ? :ok : :fail,
+                            status.success? ? 'WSLC is available' : 'WSLC version failed')
+    rescue Errno::ENOENT
+      results << Result.new(:fail, 'WSLC version failed')
+    end
+
+    def result(condition, ok_message, fail_message)
+      Result.new(condition,
+                 condition == :ok ? ok_message : fail_message)
+    end
+
+    def command_available?(name) = ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, name)) }
+  end
+end

data/lib/wip/environment.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Wip
+  # Detects WSL2, Windows interop, and architecture facts about the host.
+  class Environment
+    def initialize(stdin: $stdin, stdout: $stdout)
+      @stdin = stdin
+      @stdout = stdout
+    end
+
+    def wsl2?
+      File.read('/proc/version').match?(/microsoft.*WSL2/i)
+    rescue Errno::ENOENT
+      false
+    end
+
+    def windows_interop? = File.executable?('/proc/sys/fs/binfmt_misc/WSLInterop') || ENV.key?('WSL_INTEROP')
+    def interactive? = @stdin.tty? && @stdout.tty?
+
+    def architecture
+      machine = `uname -m`.strip
+      { 'x86_64' => 'linux/amd64', 'aarch64' => 'linux/arm64', 'arm64' => 'linux/arm64' }.fetch(machine,
+                                                                                                "linux/#{machine}")
+    end
+  end
+end

data/lib/wip/error_interpreter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Wip
+  # Translates raw WSLC error output into friendlier hints.
+  class ErrorInterpreter
+    def initialize(architecture: Environment.new.architecture)
+      @architecture = architecture
+    end
+
+    def interpret(output)
+      case output
+      when /pull access denied|insufficient_scope|authorization failed/i then registry_message
+      when %r{no matching manifest for linux/(?:amd64|arm64)}i then architecture_message
+      end
+    end
+
+    private
+
+    def registry_message
+      <<~TEXT
+        The container registry rejected the request.
+
+        Try logging in with:
+
+          wslc registry login -u <username> docker.io
+      TEXT
+    end
+
+    def architecture_message
+      <<~TEXT
+        The image does not contain a manifest for the current CPU architecture.
+
+        Current architecture:
+          #{@architecture}
+
+        Inspect the image with:
+
+          docker buildx imagetools inspect <image>
+
+        Rebuild and push a multi-platform image with:
+
+          docker buildx build \\
+            --platform linux/amd64,linux/arm64 \\
+            -t <image> \\
+            --push .
+      TEXT
+    end
+  end
+end

data/lib/wip/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Wip
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class CommandNotFoundError < Error; end
+end

data/lib/wip/version.rb

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

data/lib/wip.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'wip/version'
+require_relative 'wip/errors'
+require_relative 'wip/config'
+require_relative 'wip/config_loader'
+require_relative 'wip/environment'
+require_relative 'wip/command_resolver'
+require_relative 'wip/error_interpreter'
+require_relative 'wip/command_builder'
+require_relative 'wip/command_runner'
+require_relative 'wip/doctor'
+require_relative 'wip/cli'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: wslc-wip
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Wip contributors
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Wip provides project commands and diagnostics for WSLC development environments.
+executables:
+- wip
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/wip
+- lib/wip.rb
+- lib/wip/cli.rb
+- lib/wip/command_builder.rb
+- lib/wip/command_resolver.rb
+- lib/wip/command_runner.rb
+- lib/wip/config.rb
+- lib/wip/config_loader.rb
+- lib/wip/doctor.rb
+- lib/wip/environment.rb
+- lib/wip/error_interpreter.rb
+- lib/wip/errors.rb
+- lib/wip/version.rb
+homepage: https://github.com/example/wip
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A developer-friendly CLI wrapper for Microsoft WSLC
+test_files: []