esp-modkit 0.1.0

data/lib/esp/providers/ollama.rb

@@ -0,0 +1,102 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Esp
+  module Providers
+    # Ollama (local-runtime) provider. Talks to Ollama's OpenAI-compatible
+    # Chat Completions endpoint (`<base>/v1/chat/completions`), so it reuses
+    # the OpenAI provider's request/response translation in full — the only
+    # differences are the base URL, a placeholder API key (the openai gem
+    # requires one but Ollama ignores it), and a reachability probe in place
+    # of "key is set" for the `configured?` semantic.
+    #
+    # `auto_default: false` at registration time means Ollama is never picked
+    # automatically — the user selects it explicitly in the UI, so a reachable
+    # local runtime doesn't mask an un-keyed cloud provider.
+    class Ollama < OpenAI
+      DEFAULT_MODEL = 'llama3.2'.freeze
+      DEFAULT_BASE_URL = 'http://localhost:11434/v1'.freeze
+      ENV_KEY = 'OLLAMA_BASE_URL'.freeze
+      PROBE_TIMEOUT = 0.25   # seconds — keep snappy, the UI hits this on /providers
+      PROBE_TTL = 3.0        # cache reachability so refreshes don't hammer Ollama
+
+      # Class-level probe cache, keyed by base URL. Mutexed so a threaded
+      # WEBrick request doesn't race the cache.
+      @probe_cache = {}
+      @probe_mutex = Mutex.new
+
+      class << self
+        # `configured?` = reachable, not "env set" — the base URL has a default,
+        # so the var being unset is the *common* case rather than misconfigured.
+        def configured?
+          reachable?
+        end
+
+        # GET /api/version against the configured base, with a tight timeout
+        # and a short-lived cache. Returns true iff Ollama answered 2xx.
+        def reachable?(base_url: nil)
+          url = base_url || ENV.fetch(ENV_KEY, DEFAULT_BASE_URL)
+          @probe_mutex.synchronize do
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            cached = @probe_cache[url]
+            return cached[:value] if cached && now - cached[:at] < PROBE_TTL
+
+            value = probe(url)
+            @probe_cache[url] = { at: now, value: value }
+            value
+          end
+        end
+
+        # Cleared between tests so caching doesn't leak between scenarios.
+        def reset_probe_cache!
+          @probe_mutex.synchronize { @probe_cache.clear }
+        end
+
+        # GET /api/tags → list of installed models for the model-input
+        # autocomplete (slice 3). Returns [] on any failure — auto-discovery
+        # is convenience, not capability; if Ollama is down or slow the user
+        # still types the model name by hand.
+        def list_models(base_url: nil)
+          url = base_url || ENV.fetch(ENV_KEY, DEFAULT_BASE_URL)
+          uri = URI("#{url.sub(%r{/v1/?\z}, '')}/api/tags")
+          res = Net::HTTP.start(uri.host, uri.port, open_timeout: PROBE_TIMEOUT,
+                                                    read_timeout: 2.0) do |http|
+            http.get(uri.path.empty? ? '/api/tags' : uri.path)
+          end
+          return [] unless res.is_a?(Net::HTTPSuccess)
+
+          (JSON.parse(res.body)['models'] || []).map { |m| m['name'] }.compact
+        rescue StandardError
+          []
+        end
+
+        private
+
+        # Hit Ollama's native /api/version (sits at the host root, not under
+        # /v1). Anything raised → not reachable.
+        def probe(base_url)
+          uri = URI("#{base_url.sub(%r{/v1/?\z}, '')}/api/version")
+          Net::HTTP.start(uri.host, uri.port, open_timeout: PROBE_TIMEOUT,
+                                              read_timeout: PROBE_TIMEOUT) do |http|
+            http.get(uri.path.empty? ? '/' : uri.path).is_a?(Net::HTTPSuccess)
+          end
+        rescue StandardError
+          false
+        end
+      end
+
+      def build_default_client
+        require 'openai'
+        ::OpenAI::Client.new(
+          base_url: ENV.fetch(ENV_KEY, DEFAULT_BASE_URL),
+          # The openai gem requires a non-nil api_key; Ollama ignores it.
+          api_key: 'ollama'
+        )
+      end
+    end
+
+    register('ollama', Ollama, default_model: Ollama::DEFAULT_MODEL,
+                               env_key: Ollama::ENV_KEY, auto_default: false)
+  end
+end

data/lib/esp/providers/openai.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module Esp
+  module Providers
+    # The OpenAI Chat Completions implementation of the provider contract, via
+    # the official `openai` gem. The neutral transcript maps to chat messages:
+    # the system prompt is a leading message (not a separate param), each tool
+    # result is its own role:'tool' message (vs Anthropic's single grouped user
+    # message), and the assistant turn is replayed from the stored native
+    # message. Tools become OpenAI function definitions; arguments arrive as a
+    # JSON string. Client injected for tests; real one built lazily.
+    class OpenAI
+      DEFAULT_MODEL = 'gpt-4o'.freeze
+      ENV_KEY = 'OPENAI_API_KEY'.freeze
+
+      # "Configured" = the SDK has a key to authenticate with.
+      def self.configured?
+        !ENV.fetch(ENV_KEY, '').to_s.empty?
+      end
+
+      def initialize(client: nil, model: DEFAULT_MODEL)
+        @client = client
+        @model = model
+      end
+
+      def complete(system:, tools:, messages:)
+        response = client.chat.completions.create(
+          model: @model,
+          messages: native_messages(system, messages),
+          tools: tools.map { |tool| tool_def(tool) }
+        )
+        message = response.choices.first.message
+        tool_calls = Array(message.tool_calls).map do |call|
+          { id: call.id, name: call.function.name, input: parse_args(call.function.arguments) }
+        end
+        Completion.new(text: message.content.to_s, tool_calls: tool_calls,
+                       raw: native_assistant(message.content, tool_calls))
+      end
+
+      private
+
+      def native_messages(system, messages)
+        native = [{ role: 'system', content: system }]
+        messages.each do |msg|
+          case msg[:role]
+          when :user      then native << { role: 'user', content: msg[:text] }
+          when :assistant then native << msg[:raw]
+          when :tool      then msg[:results].each { |result| native << tool_message(result) }
+          end
+        end
+        native
+      end
+
+      def tool_message(result)
+        { role: 'tool', tool_call_id: result[:id], content: result[:content] }
+      end
+
+      # Reconstruct the assistant message as a plain hash to replay next turn.
+      def native_assistant(content, tool_calls)
+        native = { role: 'assistant', content: content }
+        unless tool_calls.empty?
+          native[:tool_calls] = tool_calls.map do |call|
+            { id: call[:id], type: 'function',
+              function: { name: call[:name], arguments: JSON.generate(call[:input]) } }
+          end
+        end
+        native
+      end
+
+      def tool_def(tool)
+        { type: 'function',
+          function: { name: tool[:name], description: tool[:description], parameters: tool[:input_schema] } }
+      end
+
+      def parse_args(arguments)
+        arguments.nil? || arguments.empty? ? {} : JSON.parse(arguments)
+      end
+
+      def client
+        @client ||= build_default_client
+      end
+
+      def build_default_client
+        require 'openai'
+        ::OpenAI::Client.new(api_key: ENV.fetch('OPENAI_API_KEY', nil))
+      end
+    end
+
+    register('openai', OpenAI, default_model: OpenAI::DEFAULT_MODEL, env_key: OpenAI::ENV_KEY)
+  end
+end

data/lib/esp/providers.rb

@@ -0,0 +1,76 @@
+module Esp
+  # The LLM-provider seam behind Esp::Agent. Each provider translates the
+  # agent's neutral transcript to its API's native wire shape and normalizes
+  # the response back to a Completion. Providers self-register here, so adding
+  # one is a new file under providers/ plus a require in the load manifest.
+  #
+  # Provider contract:
+  #   #complete(system:, tools:, messages:) -> Completion(text:, tool_calls:, raw:)
+  #     system   — String system prompt
+  #     tools    — Array<{name:, description:, input_schema:}> (JSON-Schema)
+  #     messages — the neutral transcript (see Esp::Agent)
+  #     raw      — the provider-native assistant *message* for this turn, stored
+  #                on the assistant entry and replayed verbatim next call so
+  #                provider-side state (Anthropic thinking signatures, OpenAI
+  #                tool_calls) survives multi-turn tool use.
+  module Providers
+    Completion = Struct.new(:text, :tool_calls, :raw, keyword_init: true)
+    # `auto_default` decides whether default_id can pick this provider when no
+    # ESP_PROVIDER override is set — false providers (Ollama) require the user
+    # to choose explicitly, so a reachable local runtime never masks an
+    # un-keyed cloud provider.
+    Entry = Struct.new(:id, :klass, :default_model, :env_key, :auto_default, keyword_init: true)
+    class UnknownProvider < ArgumentError; end
+
+    class << self
+      # The id → Entry map, lazily initialized and populated by providers at
+      # load time (a plain mutable hash, hence not a frozen constant).
+      def registry
+        @registry ||= {}
+      end
+
+      # Providers call this at load time. `env_key` names the environment
+      # variable that carries the API key (the shell injects it per provider).
+      # Provider classes must define `self.configured?` — usually "env key set"
+      # for cloud providers, "reachable" for local runtimes. `auto_default:
+      # false` keeps a provider out of automatic default selection (used by
+      # Ollama so the user picks it explicitly).
+      def register(id, klass, default_model:, env_key:, auto_default: true)
+        registry[id] = Entry.new(id: id, klass: klass, default_model: default_model,
+                                 env_key: env_key, auto_default: auto_default)
+      end
+
+      # Instantiate a provider by id, with an optional model override (blank →
+      # the provider's default). Extra opts (e.g. an injected client) pass
+      # through for tests.
+      def build(id, model: nil, **)
+        entry = registry.fetch(id.to_s) { raise UnknownProvider, Esp.t('errors.providers.unknown', id: id) }
+        chosen = model.nil? || model.to_s.empty? ? entry.default_model : model
+        entry.klass.new(model: chosen, **)
+      end
+
+      # The providers a client can choose from: id, default model, and whether
+      # each provider considers itself configured (per its own `configured?`
+      # — env-key presence for cloud providers, reachability probe for local).
+      def available
+        registry.values.map do |entry|
+          { id: entry.id, default_model: entry.default_model.to_s,
+            configured: entry.klass.configured? }
+        end
+      end
+
+      # The provider to use when the caller doesn't pick one: an explicit
+      # ESP_PROVIDER override (legacy MW_PROVIDER still honoured until step
+      # 24 ships), else the first *auto-default* configured provider, else
+      # the first registered. Manual-only providers (Ollama) are excluded
+      # from automatic selection — see Entry#auto_default.
+      def default_id
+        override = ENV['ESP_PROVIDER'] || ENV.fetch('MW_PROVIDER', nil)
+        return override if registry.key?(override.to_s)
+
+        preferred = registry.values.find { |entry| entry.auto_default && entry.klass.configured? }
+        preferred ? preferred.id : registry.keys.first
+      end
+    end
+  end
+end

data/lib/esp/recents.rb

@@ -0,0 +1,74 @@
+require 'json'
+require 'fileutils'
+require 'time'
+
+module Esp
+  # Per-user "recently opened projects" list, persisted as JSON in the data
+  # directory the Tauri shell injects via ESP_DATA_DIR (macOS:
+  # ~/Library/Application Support/com.coreyellis.espresso/). Falls back to
+  # ~/.config/esp/ for CLI / unit-test use. The MW_DATA_DIR env var still
+  # works as a one-release deprecation alias so existing dev shells keep
+  # finding the same on-disk state; remove after step 24 ships.
+  # Single-writer per process — the mutex serialises threaded WEBrick
+  # handlers; cross-process collisions are accepted in v1 (one ESPresso ↔
+  # one backend).
+  module Recents
+    CAP = 10
+
+    @mutex = Mutex.new
+
+    class << self
+      def path
+        File.join(data_dir, 'recents.json')
+      end
+
+      def data_dir
+        ENV['ESP_DATA_DIR'] || ENV['MW_DATA_DIR'] || File.expand_path('~/.config/esp')
+      end
+
+      # The current list, newest-first. Missing or malformed file → [] (we'd
+      # rather start clean than block the landing on a parse error).
+      def list
+        @mutex.synchronize { read_unsafe }
+      end
+
+      # Record an opened project: dedupe by root, prepend, cap. Returns the
+      # updated list so callers don't have to re-read.
+      def add(root)
+        normalized = File.expand_path(root.to_s)
+        @mutex.synchronize do
+          entries = read_unsafe.reject { |entry| entry['root'] == normalized }
+          entries.unshift(
+            'root' => normalized,
+            'name' => File.basename(normalized),
+            'opened_at' => Time.now.utc.iso8601
+          )
+          entries = entries.first(CAP)
+          write_unsafe(entries)
+          entries
+        end
+      end
+
+      # Used by tests to start from a known state.
+      def clear!
+        @mutex.synchronize { write_unsafe([]) }
+      end
+
+      private
+
+      def read_unsafe
+        return [] unless File.exist?(path)
+
+        parsed = JSON.parse(File.read(path))
+        parsed.is_a?(Array) ? parsed : []
+      rescue StandardError
+        []
+      end
+
+      def write_unsafe(entries)
+        FileUtils.mkdir_p(data_dir)
+        File.write(path, "#{JSON.pretty_generate(entries)}\n")
+      end
+    end
+  end
+end

data/lib/esp/ui.rb

@@ -0,0 +1,144 @@
+require 'yaml'
+
+module Esp
+  # Shorthand for the tool-UI translator. Lib code calls Esp.t(...); the CLI's
+  # Support mixin exposes the same thing as t(...). Heavier UI calls (audit,
+  # with_locale, locale=) still go through Esp::UI directly.
+  def self.t(key, **vars)
+    UI.t(key, **vars)
+  end
+
+  # Internal i18n for the *tool's own* user-facing strings — CLI output and
+  # error messages. Distinct from Esp::Mw::I18n, which localizes mod *content*;
+  # this localizes mw itself so the distributed tool can ship in other
+  # languages.
+  #
+  # Catalogues live at locales/<locale>.yml, resolved relative to this file
+  # (they ship with the tool, independent of Esp::ROOT — which points at the
+  # user's mod project). Lookup is dot-pathed with %{named} interpolation,
+  # falling back to en, then to the key itself.
+  #
+  # Active locale: ESP_UI_LOCALE (with MW_UI_LOCALE honoured as a one-release
+  # deprecation alias), then LANG/LC_ALL (stripped to the language subtag,
+  # e.g. "fr_FR.UTF-8" -> "fr"), then en. Tests pin it to en.
+  module UI
+    DEFAULT_LOCALE = 'en'.freeze
+    LOCALES_DIR = File.expand_path('../../locales', __dir__)
+
+    class << self
+      def t(key, **vars)
+        template = lookup(locale, key) || lookup(DEFAULT_LOCALE, key) || key
+        return template if vars.empty?
+
+        interpolate(template, vars, key)
+      end
+
+      def locale
+        @locale ||= detect_locale
+      end
+
+      attr_writer :locale
+
+      def with_locale(value)
+        previous = locale
+        @locale = value
+        yield
+      ensure
+        @locale = previous
+      end
+
+      # Quoted dotted literal, e.g. 'cli.build.done' or "errors.no_index".
+      # Starts lowercase so it skips "Morrowind.esm" and version numbers.
+      KEY_LITERAL = /(['"])([a-z]\w*(?:\.\w+)+)\1/
+
+      # Audit the catalogues against the code:
+      #   undefined — a UI-namespaced key referenced in lib but absent from
+      #               en (a bug: the user would see the raw key)
+      #   unused    — defined in en but referenced nowhere (dead/typo)
+      #   orphans   — per non-en locale, keys not present in en (stale)
+      #   missing   — per non-en locale, en keys it doesn't translate
+      #               (falls back to en; informational — partials are fine)
+      #
+      # Detection is a literal scan, so it's robust to call form (ternary
+      # args, the `t` helper, `Esp::UI.t`). A key counts as referenced if its
+      # quoted literal appears anywhere in lib. "undefined" is scoped to the
+      # UI namespaces (en's top-level keys), so mod-content t() keys and doc
+      # examples don't masquerade as missing UI strings.
+      def audit(lib_dir: File.expand_path('..', __dir__))
+        en = (catalogues[DEFAULT_LOCALE] || {}).keys
+        namespaces = en.map { |k| k.split('.').first }.uniq
+        referenced = referenced_keys(lib_dir)
+        ui_referenced = referenced.select { |k| namespaces.include?(k.split('.').first) }
+        others = catalogues.reject { |loc, _| loc == DEFAULT_LOCALE }
+        {
+          undefined: (ui_referenced - en).sort,
+          unused: (en - referenced).sort,
+          orphans: others.transform_values { |c| (c.keys - en).sort }.reject { |_, v| v.empty? },
+          missing: others.transform_values { |c| (en - c.keys).sort }.reject { |_, v| v.empty? }
+        }
+      end
+
+      private
+
+      # Interpolate %{named} vars. A broken *translation* (a locale template
+      # referencing a var we weren't given — e.g. a typo'd %{nom}) must not
+      # crash the tool for that locale's users: fall back to the en template,
+      # then to the raw string.
+      def interpolate(template, vars, key)
+        format(template, vars)
+      rescue KeyError, ArgumentError
+        fallback = lookup(DEFAULT_LOCALE, key)
+        return template unless fallback && fallback != template
+
+        safe_format(fallback, vars)
+      end
+
+      def safe_format(template, vars)
+        format(template, vars)
+      rescue KeyError, ArgumentError
+        template
+      end
+
+      # Every quoted dotted literal across lib (used to decide both what's
+      # referenced and what's unused).
+      def referenced_keys(dir)
+        Dir.glob(File.join(dir, '**', '*.rb')).flat_map do |file|
+          File.read(file).scan(KEY_LITERAL).map { |_quote, key| key }
+        end.uniq
+      end
+
+      def detect_locale
+        raw = ENV['ESP_UI_LOCALE'] || ENV['MW_UI_LOCALE'] || ENV['LANG'] || ENV['LC_ALL'] || DEFAULT_LOCALE
+        tag = raw.to_s.split(/[._]/).first.to_s
+        tag.empty? ? DEFAULT_LOCALE : tag
+      end
+
+      def lookup(loc, key)
+        catalogues.dig(loc, key)
+      end
+
+      def catalogues
+        @catalogues ||= load_catalogues
+      end
+
+      def load_catalogues
+        return {} unless File.directory?(LOCALES_DIR)
+
+        Dir.glob(File.join(LOCALES_DIR, '*.yml')).to_h do |path|
+          [File.basename(path, '.yml'), flatten(YAML.safe_load_file(path) || {})]
+        end
+      end
+
+      def flatten(hash, prefix = '')
+        hash.each_with_object({}) do |(k, v), out|
+          key = prefix.empty? ? k.to_s : "#{prefix}.#{k}"
+          if v.is_a?(Hash)
+            out.merge!(flatten(v, key))
+          else
+            out[key] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/esp/vcs.rb

@@ -0,0 +1,112 @@
+require 'open3'
+require 'fileutils'
+
+module Esp
+  # A thin wrapper over the `git` CLI, scoped to a working-tree `root`. Backs
+  # the diff-review loop (step 20): list working-tree changes, show one file's
+  # diff, stage approved files, discard rejected ones. We shell out rather than
+  # bind libgit2 (nothing extra to ship) — the project is already a git repo.
+  #
+  # Every method takes an explicit `root` so it operates on the *user's* mod
+  # project, never the toolchain repo, and so it's testable against a scratch
+  # repo. Git failures raise GitError; the Operations layer maps that to a
+  # caller-facing error.
+  module Vcs
+    Change = Struct.new(:path, :status, :staged, keyword_init: true)
+    class GitError < StandardError; end
+
+    class << self
+      # Working-tree changes under `scope` (a path prefix, e.g. "mods"), each a
+      # Change with status ∈ added | modified | deleted | renamed and a staged
+      # flag. Untracked files show up as `added`.
+      def changes(root:, scope: nil)
+        scope_args = scope.nil? || scope.empty? ? [] : ['--', scope]
+        parse_status(capture(root, 'status', '--porcelain=v1', '-z', *scope_args))
+      end
+
+      # Unified diff of one file against HEAD. An untracked (agent-created) file
+      # has no HEAD entry, so we diff it against the null device to render it as
+      # an all-add patch.
+      def file_diff(root:, path:)
+        if tracked?(root, path)
+          capture(root, 'diff', 'HEAD', '--', path)
+        else
+          # --no-index exits 1 whenever the files differ; that's expected here,
+          # not a failure.
+          capture(root, 'diff', '--no-index', '--', File::NULL, path, allow_fail: true)
+        end
+      end
+
+      # Stage approved paths (`git add`). The change stays in the working tree;
+      # the human commits when ready.
+      def stage(root:, paths:)
+        return if paths.empty?
+
+        run(root, 'add', '--', *paths)
+      end
+
+      # Discard a rejected change: restore a tracked file to HEAD, delete an
+      # agent-created untracked file. Destructive — callers confirm first.
+      def discard(root:, path:)
+        if tracked?(root, path)
+          run(root, 'checkout', 'HEAD', '--', path)
+        else
+          File.delete(File.join(root, path))
+        end
+      end
+
+      def tracked?(root, path)
+        !capture(root, 'ls-files', '--', path).strip.empty?
+      end
+
+      # Initialise a git repo at `root`. Used by the new-project flow
+      # (step 23 slice 5) so the freshly-scaffolded project tree is a
+      # tracked working tree from minute one.
+      def run_git_init(root)
+        FileUtils.mkdir_p(root)
+        run(root, 'init', '-q')
+      end
+
+      private
+
+      # Porcelain v1 -z: NUL-separated `XY PATH` records; a rename/copy is
+      # followed by its original path in the next field, which we consume.
+      def parse_status(output)
+        tokens = output.split("\0")
+        changes = []
+        i = 0
+        while i < tokens.length
+          entry = tokens[i]
+          i += 1
+          next if entry.to_s.empty?
+
+          code = entry[0, 2]
+          i += 1 if code.start_with?('R', 'C') # skip the rename/copy source path
+          changes << Change.new(path: entry[3..], status: status_for(code),
+                                staged: code[0] != ' ' && code[0] != '?')
+        end
+        changes
+      end
+
+      def status_for(code)
+        return 'added'    if code == '??' || code.include?('A')
+        return 'deleted'  if code.include?('D')
+        return 'renamed'  if code.start_with?('R')
+
+        'modified'
+      end
+
+      def run(root, *)
+        capture(root, *)
+        nil
+      end
+
+      def capture(root, *args, allow_fail: false)
+        out, status = Open3.capture2e('git', '-C', root.to_s, *args)
+        raise GitError, "git #{args.first} failed: #{out.strip}" unless status.success? || allow_fail
+
+        out
+      end
+    end
+  end
+end

data/lib/esp/version.rb

@@ -0,0 +1,11 @@
+module Esp
+  VERSION = '0.1.0'.freeze
+
+  # Minimum Ruby the gem supports. Pinned to the version we actually develop
+  # and lint against (.ruby-version is 3.3.3, RuboCop TargetRubyVersion 3.3),
+  # so the claim is verifiable rather than aspirational. Widening to 3.1
+  # later means adding a real 3.1 CI lane first. The gemspec's
+  # required_ruby_version and `esp doctor` both read this so the two never
+  # drift.
+  MINIMUM_RUBY_VERSION = '3.3'.freeze
+end

data/lib/esp/watcher.rb

@@ -0,0 +1,55 @@
+require 'listen'
+
+module Esp
+  # File-watch-driven rebuild. Watches a mod's source directory (and
+  # its scripts/, i18n/, etc. subtrees) and re-invokes Esp::Mw::Builder on
+  # any matching change. Blocks until SIGINT.
+  class Watcher
+    WATCHED_EXTS = %w[.json .rb .py .js .mjs .ts .mwscript .yaml .yml].freeze
+
+    def initialize(mod, locale: nil, root: Esp::ROOT, output: $stdout)
+      @mod = mod
+      @locale = locale
+      @root = root
+      @output = output
+    end
+
+    def start
+      source_dir = File.dirname(Esp::Mw::Loader.resolve(@mod, root: @root))
+
+      rebuild
+      log "watching #{relative(source_dir)} (Ctrl-C to stop)"
+
+      listener = Listen.to(source_dir, only: extensions_regex, latency: 0.2) { rebuild }
+      listener.start
+      trap('INT') do
+        listener.stop
+        log 'stopped.'
+        exit 0
+      end
+      sleep
+    end
+
+    private
+
+    def rebuild
+      stamp = Time.now.strftime('%H:%M:%S')
+      result = Esp::Mw::Builder.build(@mod, root: @root, locale: @locale)
+      log "[#{stamp}] build ok -> #{relative(result.output)}"
+    rescue StandardError => e
+      log "[#{stamp}] build failed: #{e.message}"
+    end
+
+    def extensions_regex
+      Regexp.new("(#{WATCHED_EXTS.map { |e| Regexp.escape(e) }.join('|')})\\z")
+    end
+
+    def log(message)
+      @output.puts(message)
+    end
+
+    def relative(path)
+      path.sub("#{@root}/", '')
+    end
+  end
+end