lux-hammer 0.3.12 → 0.3.14

data/lib/hammer/parser.rb

@@ -8,9 +8,9 @@ class Hammer
       @options    = options
       @by_switch  = {}
       options.each do |opt|
-        @by_switch[opt.switch] = opt
-        @by_switch[opt.negation] = opt if opt.boolean?
-        opt.aliases.each { |a| @by_switch[a] = opt }
+        register_switch(opt.switch, opt)
+        register_switch(opt.negation, opt) if opt.boolean?
+        opt.aliases.each { |a| register_switch(a, opt) }
       end
     end
 
@@ -31,7 +31,11 @@ class Hammer
         if token.start_with?('--') && token.include?('=')
           key, val = token.split('=', 2)
           opt = lookup!(key)
-          values[opt.name] = opt.cast(val)
+          if opt.boolean? && key.start_with?('--no-')
+            values[opt.name] = !opt.cast(val)   # `--no-x=false` -> true
+          else
+            values[opt.name] = opt.cast(val)
+          end
           i += 1
           next
         end
@@ -50,7 +54,18 @@ class Hammer
           next
         end
 
-        if token.start_with?('-') && token.length > 1
+        # Glued short flag with value: `-pVALUE` (non-boolean short opts only).
+        if token.start_with?('-') && !token.start_with?('--') && token.length > 2
+          if (opt = @by_switch[token[0, 2]]) && !opt.boolean?
+            values[opt.name] = opt.cast(token[2..])
+            i += 1
+            next
+          end
+        end
+
+        # Dash-led and not a negative number -> a genuinely unknown flag.
+        # Bare `-` and negative numbers (`-5`) fall through to positionals.
+        if token.start_with?('-') && token.length > 1 && token !~ /\A-\d/
           raise Error, "unknown option: #{token}"
         end
 
@@ -59,15 +74,21 @@ class Hammer
       end
 
       # Fill un-set non-boolean opts from positional args in declaration
-      # order. Booleans always need an explicit flag.
+      # order. Booleans always need an explicit flag. Scalars take one
+      # positional each; an :array opt slurps whatever's left, so it's
+      # filled last and never starves a later-declared scalar opt.
+      array_opt = nil
       @options.each do |opt|
-        break if positional.empty?
         next if opt.boolean? || values.key?(opt.name)
         if opt.type == :array
-          values[opt.name] = opt.cast(positional.shift(positional.size))
-        else
-          values[opt.name] = opt.cast(positional.shift)
+          array_opt = opt
+          next
         end
+        break if positional.empty?
+        values[opt.name] = opt.cast(positional.shift)
+      end
+      if array_opt && !positional.empty?
+        values[array_opt.name] = array_opt.cast(positional.shift(positional.size))
       end
 
       @options.each do |opt|
@@ -80,6 +101,15 @@ class Hammer
 
     private
 
+    # Map a flag string to its option, refusing silent shadowing when two
+    # options would claim the same switch/negation/alias.
+    def register_switch(flag, opt)
+      if (prev = @by_switch[flag]) && prev != opt
+        raise Error, "flag #{flag} claimed by both :#{prev.name} and :#{opt.name}"
+      end
+      @by_switch[flag] = opt
+    end
+
     def lookup!(key)
       @by_switch[key] or raise Error, "unknown option: #{key}"
     end

data/lib/hammer/recipe.rb

@@ -49,14 +49,14 @@ class Hammer
       ''
     end
 
-    # Ruby wrapper text printed by `hammer recipes --install`. User
+    # Ruby wrapper text printed by `hammer h:recipes --install`. User
     # redirects it to a file in PATH and chmods +x. The leading comment
     # documents the canonical install command. Name is passed as a
     # string literal so hyphenated names (`git-helper`) work too.
     def stub(name)
       <<~RUBY
         #!/usr/bin/env ruby
-        # install: hammer recipes --install #{name} > ~/bin/#{name} && chmod +x $_
+        # install: hammer h:recipes --install #{name} > ~/bin/#{name} && chmod +x $_
         require 'lux-hammer'
         Hammer.recipe('#{name}', ARGV)
       RUBY

data/lib/hammer/shell.rb

@@ -13,8 +13,11 @@ class Hammer
     module_function
 
     def color?
-      return @color if defined?(@color)
-      @color = $stdout.tty? && ENV['NO_COLOR'].nil?
+      # Only an explicit color!(value) override is sticky; otherwise the
+      # tty decision is recomputed so a redirected $stdout (tests, capture
+      # blocks) is honored instead of frozen at first read.
+      return @color if defined?(@color) && !@color.nil?
+      $stdout.tty? && ENV['NO_COLOR'].nil?
     end
 
     def color!(value)

data/lib/lux-hammer.rb

@@ -94,8 +94,8 @@ class Hammer
       # If the method takes no args, call it without opts. Otherwise pass
       # opts. So both `def build` and `def build(opts)` work.
       m = method_name
-      arity = instance_method(method_name).arity
-      cmd.handler = arity.zero? ? proc { send(m) } : proc { |opts| send(m, opts) }
+      takes_arg = instance_method(method_name).parameters.any? { |type, _| %i[req opt rest].include?(type) }
+      cmd.handler = takes_arg ? proc { |opts| send(m, opts) } : proc { send(m) }
       cmd.finalize!
       commands[cmd.name] = cmd
 
@@ -413,6 +413,13 @@ class Hammer
         return print_help
       end
 
+      # An exact namespace beats a fuzzy command match, so `hammer h` lists
+      # the `h:` namespace instead of prefix-matching some `h...` command.
+      if !commands.key?(name) && namespaces.key?(name)
+        ns, canonical = resolve_namespace(name)
+        return print_namespace_help(canonical, ns)
+      end
+
       cmd, owner, canonical = resolve(name)
       return owner.run_command(cmd, argv, full: canonical) if cmd
 
@@ -518,6 +525,7 @@ class Hammer
     # Tries prefix match first, then substring; raises AmbiguousMatch
     # when either pass hits more than one item.
     def fuzzy_pick(name, items, kind, &keys_for)
+      return nil if name.empty?
       [:start_with?, :include?].each do |op|
         matches = items.select { |item| keys_for.call(item).any? { |k| k.send(op, name) } }
         next if matches.empty?
@@ -548,24 +556,66 @@ class Hammer
       opts.each do |k, v|
         next if v == false
         flag = "--#{k.to_s.tr('_', '-')}"
-        argv << (v == true ? flag : "#{flag}=#{v}")
+        if v == true
+          argv << flag
+        else
+          argv << "#{flag}=#{v.is_a?(Array) ? v.join(',') : v}"
+        end
       end
       start(argv)
     end
 
     # Yield [full_colon_path, Command] for every command in this class
-    # and all nested namespaces.
-    def each_command(prefix = nil, &block)
+    # and all nested namespaces. `include_builtins: false` prunes
+    # namespaces flagged `@builtin_namespace` (the reserved `h:` tree) -
+    # used so the compact listing hides built-ins outside `--help`. Only
+    # affects descent from a parent; iterating a flagged namespace
+    # directly (e.g. `hammer h:`) still lists its own commands.
+    def each_command(prefix = nil, include_builtins: true, &block)
       commands.each_value do |c|
         full = prefix ? "#{prefix}:#{c.name}" : c.name
         yield full, c
       end
       namespaces.each do |ns_name, sub|
+        next if !include_builtins && sub.instance_variable_get(:@builtin_namespace)
         sub_prefix = prefix ? "#{prefix}:#{ns_name}" : ns_name
-        sub.each_command(sub_prefix, &block)
+        sub.each_command(sub_prefix, include_builtins: include_builtins, &block)
       end
     end
 
+    # Machine-readable spec for `h:json` -> the macOS GUI (and, later,
+    # for lux itself to render the default listing). One hash:
+    #   commands => { group => { full_path => task_meta } }
+    # Grouping/sort mirror the bare-`hammer` listing exactly: group by
+    # the first namespace segment (a bare task sharing a namespace's name
+    # joins that group via section_for), root tasks under "__root",
+    # "__root" first, remaining groups in first-encounter order, tasks
+    # within a group by [depth, name]. Hidden (no-`desc`) tasks are
+    # skipped and the reserved `h:` tree is pruned unless include_builtins.
+    def export_spec(include_builtins: false)
+      groups = {}   # group => { full_path => meta }, in first-encounter order
+
+      each_command(include_builtins: include_builtins) do |path, c|
+        next if c.desc.empty?
+        section = section_for(path, nil, self)
+        key = section == :root ? '__root' : section.to_s
+        (groups[key] ||= {})[path] = c.to_h(path)
+      end
+
+      sort_tasks = ->(h) { h.sort_by { |p, _| [p.count(':'), p] }.to_h }
+      ordered = {}
+      ordered['__root'] = sort_tasks.call(groups.delete('__root')) if groups.key?('__root')
+      groups.each { |k, v| ordered[k] = sort_tasks.call(v) }
+
+      {
+        schema:         1,
+        hammer_version: VERSION,
+        program_name:   program_name,
+        app_desc:       app_desc,
+        commands:       ordered
+      }
+    end
+
     def run_command(cmd, argv, full: nil, quiet: false)
       # -h / --help is reserved on every command. Anywhere before a `--`
       # stop-marker, it short-circuits to per-command help.
@@ -601,17 +651,22 @@ class Hammer
         if o.boolean?
           parts << (val ? "--#{o.name}" : "--no-#{o.name}")
         else
-          parts << "--#{o.name}=#{val}"
+          parts << "--#{o.name}=#{val.is_a?(Array) ? val.join(',') : val}"
         end
       end
       parts.concat(positional)
-      Shell.say "> #{parts.join(' ')}", :gray
+      # Diagnostic, not program output - to stderr so stdout stays clean
+      # for machine-readable tasks (`h:json`, `h:version`) and pipes.
+      warn Shell.paint("> #{parts.join(' ')}", :gray)
     end
 
     # Fire `before` hooks from root down through the namespace chain.
     # Each class's hooks fire at most once per top-level `start`, so
     # prereqs dispatched via `needs` won't re-trigger them.
     def run_before_hooks(instance, opts)
+      # Built-in `h:` meta-commands parent to the project root but must not
+      # trigger the project's own `before` hooks (dotenv, env checks, ...).
+      return if instance_variable_get(:@builtin_namespace)
       ran = Thread.current[:hammer_before_ran] ||= {}
       ancestor_chain.each do |klass|
         next if ran[klass.object_id]
@@ -661,15 +716,29 @@ class Hammer
 
       print_top_banner
       Shell.say "Usage: #{program_name} COMMAND [ARGS]", :cyan
+      # Compact (bare-invocation) view only - the extended `--help` view
+      # already IS the full usage, so don't nag about it there.
+      unless extended
+        Shell.say "add `--help` to show usage help", :gray
+        # No project Hammerfile + no custom tasks loaded: point the user at
+        # `h:init`. The flag is set by `Hammer.cli` when the lookup misses.
+        if instance_variable_get(:@no_hammerfile)
+          Shell.say "no Hammerfile found in #{Dir.pwd} - run `#{program_name} h:init` to create one", :gray
+        end
+      end
       if @app_desc && !@app_desc.empty?
         Shell.say ''
         @app_desc.each_line { |l| Shell.say "  #{l.chomp}" }
       end
+      # Built-in `h:` commands only surface in the extended view
+      # (`--help` / `-h` / `help`); the bare-invocation listing stays
+      # focused on the project's own tasks. They remain dispatchable
+      # regardless - this only governs what the listing shows.
       if expanded
-        each_command { |path, c| print_full_block(path, c) unless c.desc.empty? }
+        each_command(include_builtins: extended) { |path, c| print_full_block(path, c) unless c.desc.empty? }
       else
         Shell.say ''
-        print_command_list(self)
+        print_command_list(include_builtins: extended)
       end
       print_recipes_section if extended && root.instance_variable_get(:@hammer_binary)
       print_extras if extended
@@ -688,7 +757,7 @@ class Hammer
       entries.each do |name, file|
         desc = Hammer::Recipe.desc(file)
         installed = Hammer::Recipe.installed_path(name)
-        suffix = installed ? "(installed: #{installed})" : "[install: #{program_name} recipes --install #{name}]"
+        suffix = installed ? "(installed: #{installed})" : "[install: #{program_name} h:recipes --install #{name}]"
         Shell.say "  #{name.ljust(width)}  # #{desc}"
         Shell.say "  #{' ' * width}    #{suffix}", :gray
       end
@@ -702,8 +771,8 @@ class Hammer
       Shell.say "Usage: #{program_name} #{prefix}:COMMAND [ARGS]", :cyan
       rows = []
       sibling = find_namespace_sibling(prefix)
-      rows << [prefix, sibling] if sibling && !sibling.desc.empty?
-      ns.each_command(prefix) { |path, c| rows << [path, c] unless c.desc.empty? }
+      rows << [prefix, sibling.to_h(prefix)] if sibling && !sibling.desc.empty?
+      ns.each_command(prefix) { |path, c| rows << [path, c.to_h(path)] unless c.desc.empty? }
       unless rows.empty?
         Shell.say ''
         Shell.say 'Commands:', :yellow
@@ -761,45 +830,37 @@ class Hammer
 
     # Hammerfile cheat-sheet shown under `hammer --help`. Same content
     # as `hammer --init` writes - single source of truth via
-    # `Hammer::STARTER_HAMMERFILE`. For exhaustive docs see `hammer agents`.
+    # `Hammer::STARTER_HAMMERFILE`. For exhaustive docs see `hammer h:agents`.
     def print_hammerfile_example
       Shell.say ''
       Shell.say 'Hammerfile example:', :yellow
       Shell.say Hammer::STARTER_HAMMERFILE
     end
 
-    def print_command_list(klass, prefix = nil)
-      rows = []
-      # Commands without a `desc` are hidden from listings but still
-      # dispatchable + `hammer`-callable - useful for private helpers
-      # invoked from `before` hooks or other commands (e.g. `:env`, `:app`).
-      klass.each_command(prefix) { |full, c| rows << [full, c] unless c.desc.empty? }
-      return if rows.empty?
-
-      # group by "section" = everything between the view prefix and the
-      # leaf name. Bare leaves go in :root.
-      groups = rows.group_by { |full, _| section_for(full, prefix, klass) }
-      width  = rows.map { |full, _| full.length }.max
-      first  = true
-
-      if (rooted = groups.delete(:root))
-        Shell.say 'Commands:', :yellow
-        emit_rows(rooted.sort_by { |full, _| [full.count(':'), full] }, width)
-        first = false
-      end
-
-      groups.each do |section, items|
-        Shell.say unless first
-        first = false
-        Shell.say "#{section}:", :yellow
-        emit_rows(items.sort_by { |full, _| [full.count(':'), full] }, width)
+    # Pure rendering off `export_spec` - the same grouped structure
+    # `h:json` emits, so the listing and the JSON can never drift.
+    # `export_spec` already does the work: drops hidden (no-`desc`)
+    # tasks, prunes the `h:` tree unless include_builtins, groups by
+    # first namespace segment ("__root" for bare tasks), orders "__root"
+    # first, and sorts each group by [depth, name].
+    def print_command_list(include_builtins: true)
+      groups = export_spec(include_builtins: include_builtins)[:commands]
+      return if groups.empty?
+
+      width = groups.values.flat_map(&:keys).map(&:length).max
+      groups.each_with_index do |(section, tasks), i|
+        Shell.say unless i.zero?
+        Shell.say(section == '__root' ? 'Commands:' : "#{section}:", :yellow)
+        emit_rows(tasks.to_a, width)
       end
     end
 
+    # `rows` is an array of [full_path, task_meta] - the per-task hashes
+    # from `Command#to_h` (also used to render namespace listings).
     def emit_rows(rows, width)
-      rows.each do |full, c|
-        brief = c.alts.empty? ? c.brief : "#{c.brief} (alt: #{c.alts.join(', ')})"
-        brief = "#{brief} #{Shell.paint('(redefined)', :yellow)}" if c.prev_location
+      rows.each do |full, t|
+        brief = t[:alts].empty? ? t[:brief] : "#{t[:brief]} (alt: #{t[:alts].join(', ')})"
+        brief = "#{brief} #{Shell.paint('(redefined)', :yellow)}" if t[:redefined]
         Shell.say "  #{program_name} #{full.ljust(width)}  # #{brief}"
       end
     end
@@ -911,7 +972,7 @@ class Hammer
       Shell.print_error "unknown recipe: #{name}"
       Shell.say 'available recipes:', :yellow
       Recipe.all.keys.sort.each { |n| Shell.say "  #{n}" }
-      Shell.say 'try `hammer recipes` to list with descriptions', :gray
+      Shell.say 'try `hammer h:recipes` to list with descriptions', :gray
       exit 1
     end
 
@@ -967,12 +1028,12 @@ class Hammer
     end
   RUBY
 
-  # Default install dir used by install.sh and `hammer update`.
+  # Default install dir used by install.sh and `hammer h:update`.
   SELF_UPDATE_DIR  ||= File.expand_path('~/.local/share/lux-hammer')
   SELF_UPDATE_REPO ||= 'https://github.com/dux/hammer.git'
   SELF_INSTALL_URL ||= 'https://raw.githubusercontent.com/dux/hammer/main/install.sh'
 
-  # `hammer update`: pull main in the install-script checkout and
+  # `hammer h:update`: pull main in the install-script checkout and
   # reinstall the gem. Assumes the install.sh layout - if the dir is
   # missing, point the user at the curl-pipe installer.
   def self.self_update
@@ -1013,6 +1074,7 @@ class Hammer
   def self.cli(argv = ARGV)
     argv = argv.dup
     force_system = !!argv.delete('--system')
+    launch_gui   = !!argv.delete('--gui')
 
     # Shebang invocation: `hammer /path/to/script ...args` (kernel passes
     # the script path as argv[0] for `#!/usr/bin/env hammer` files).
@@ -1026,17 +1088,25 @@ class Hammer
     end
 
     path = force_system ? nil : find_hammerfile(Dir.pwd)
+
+    # `hammer --gui` opens the native macOS runner pointed at this project
+    # (the Hammerfile's dir, or cwd when none was found). The CLI just
+    # launches the bundled app and returns.
+    return launch_gui!(path ? File.dirname(path) : Dir.pwd) if launch_gui
+
     unless path
       # No Hammerfile (or --system) - all built-ins are reachable. Bare
-      # `hammer`, `hammer recipes`, `hammer update`, `hammer agents`,
-      # `hammer version`, `hammer init` all work.
+      # `hammer`, `hammer h:recipes`, `hammer h:update`, `hammer h:agents`,
+      # `hammer h:version`, `hammer h:init` all work.
       if force_system || dispatches_to_builtin?(argv) || looks_like_builtin?(argv)
         klass = Class.new(Hammer)
         klass.instance_variable_set(:@hammer_binary, true)
+        # No project Hammerfile was found - only built-ins are loaded. The
+        # bare-invocation help uses this to note that no Hammerfile exists.
+        klass.instance_variable_set(:@no_hammerfile, true)
         klass.program_name
         require_relative 'hammer/builtins'
-        Hammer::Builtins.register_core(klass)
-        Hammer::Builtins.register_no_project(klass)
+        Hammer::Builtins.register(klass)
         klass.start(argv)
         return
       end
@@ -1060,8 +1130,8 @@ class Hammer
       Shell.say STARTER_HAMMERFILE
       Shell.say ''
       bin = File.basename($PROGRAM_NAME)
-      Shell.say "tip: run `#{bin} init` to drop the example above into ./Hammerfile", :gray
-      Shell.say "tip: run `#{bin} agents` for AI-friendly Hammerfile authoring docs", :gray
+      Shell.say "tip: run `#{bin} h:init` to drop the example above into ./Hammerfile", :gray
+      Shell.say "tip: run `#{bin} h:agents` for AI-friendly Hammerfile authoring docs", :gray
       exit 1
     end
 
@@ -1082,14 +1152,13 @@ class Hammer
     # are NOT visible during Hammerfile evaluation, only inside handlers.
     Hammer::Dotenv.load(Dir.pwd) if klass.dotenv_enabled?
 
-    # Core built-ins register AFTER Hammerfile eval so user-defined
-    # tasks win (the `unless commands.key?(...)` guards in register_core
-    # skip the built-in when overridden - no redefinition warning).
-    # `register_no_project` (:recipes, :init) is intentionally NOT
-    # called here - those would clash too easily with user tasks. Use
-    # `hammer --system recipes` to reach them from inside a project.
+    # Built-ins register AFTER Hammerfile eval so user-defined tasks win
+    # (the `unless commands.key?(...)` guards skip a built-in when the
+    # Hammerfile already owns the name - no redefinition warning). All
+    # built-ins live under `h:`, so they can't collide with project root
+    # tasks and the full set registers in every context.
     require_relative 'hammer/builtins'
-    Hammer::Builtins.register_core(klass)
+    Hammer::Builtins.register(klass)
 
     klass.start(argv)
   end
@@ -1109,7 +1178,7 @@ class Hammer
   end
 
   # Evaluate a shebang script as a self-contained CLI. Mirrors `recipe`
-  # semantics: no chdir, no `@hammer_binary` flag, no `register_core`
+  # semantics: no chdir, no `@hammer_binary` flag, no `Builtins.register`
   # built-ins (so the script's `--help` shows only what it defines).
   # `program_name` is the script's basename so help reads "myscript foo"
   # rather than "hammer foo" - works even when invoked via a symlink in
@@ -1131,15 +1200,14 @@ class Hammer
     first == 'help' || first == '-h' || first == '--help' || first.start_with?('-')
   end
 
-  # True if argv names a built-in task (`recipes`, `update`, `agents`,
-  # `version`, `init`). Used in the no-Hammerfile branch to wake up the
-  # built-ins for invocations like `hammer recipes` that aren't a flag
+  # True if argv targets the reserved `h:` built-in namespace (`h`, `h:`,
+  # `h:update`, ...). Used in the no-Hammerfile branch to wake up the
+  # built-ins for invocations like `hammer h:recipes` that aren't a flag
   # or help request.
-  BUILTIN_TASKS ||= %w[recipes update agents version init].freeze
   def self.looks_like_builtin?(argv)
     first = argv.first
     return false unless first
-    BUILTIN_TASKS.include?(first) || BUILTIN_TASKS.any? { |t| first.start_with?("#{t}:") }
+    first == 'h' || first.start_with?('h:')
   end
 
   # Walk up the directory tree looking for a Hammerfile.
@@ -1154,4 +1222,21 @@ class Hammer
     end
   end
 
+  # Spawn the vendored macOS GUI (gui/Hammer.app), pointed at the project
+  # dir and this hammer binary. Launched directly (not via `open`) so it
+  # inherits the caller's environment - the GUI shells back out to this
+  # same `hammer` for `h:json` and task runs, and that needs the same PATH.
+  def self.launch_gui!(project_dir)
+    bin = File.expand_path('../gui/Hammer.app/Contents/MacOS/HammerGUI', __dir__)
+    unless File.executable?(bin)
+      Shell.print_error "GUI app not found at #{bin}"
+      Shell.say 'build it: ./gui/HammerGUI/build_app.sh', :yellow
+      exit 1
+    end
+    hammer_bin = (File.realpath($PROGRAM_NAME) rescue File.expand_path($PROGRAM_NAME))
+    pid = Process.spawn(bin, '--project', File.expand_path(project_dir), '--hammer', hammer_bin)
+    Process.detach(pid)
+    Shell.say "launched Hammer GUI for #{project_dir} (pid #{pid})", :green
+  end
+
 end

data/recipes/deploy.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env hammer
+# desc: SSH/rsync deploy - Caddy + systemd + atomic releases
+
+desc <<~TXT
+  Stupid-simple SSH/rsync deploy (Caddy + systemd + atomic releases).
+
+  Quickstart:
+    deploy app:init          # copy templates into ./config/deploy/
+    deploy doctor            # check & prep the host
+    deploy up                # deploy current branch
+
+  Server:
+    deploy server:log        # tail the systemd journal
+    deploy server:ssh        # shell into the current release
+    deploy server:restart    # restart the web service
+    deploy log --log errors  # dump a remote log
+TXT
+
+# Loads the bundled lib (config/ssh/template/doctor/context/manifest/
+# commands/hammer) - same require chain the gem's lib/lux_deploy.rb had.
+require_relative 'lib/deploy/boot'
+
+# Auto-load the app's deploy bootstrap, if present, before tasks fire.
+# A consumer can inject Ruby (e.g. a pre-deploy hook) without writing a
+# custom Hammerfile.
+init = File.join(Dir.pwd, 'config', 'deploy', 'init.rb')
+load init if File.file?(init)
+
+# `self` here is the recipe's Builder context - same surface a Hammerfile
+# gets. Pass templates_dir explicitly since there's no gem ROOT to fall
+# back to; it resolves to recipes/lib/deploy/templates.
+LuxDeploy::Hammer.register(self, templates_dir: File.join(__dir__, 'lib/deploy/templates'))

data/recipes/git-helper.rb

@@ -142,8 +142,8 @@ helpers do
       if message.empty?
         run 'git reset --mixed'
         exit
-      elsif message.length < 5
-        say 'Please add better commit message, min length 5 chars', :red
+      elsif message.length < 1
+        say 'Please add better commit message, min length 1 chars', :red
         next
       else
         bump_version

data/recipes/lib/deploy/boot.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+require 'pathname'
+require 'open3'
+require 'set'
+require 'shellwords'
+require 'yaml'
+
+module LuxDeploy
+  # Recipe layout: this file and its siblings live under
+  # recipes/lib/deploy/, so ROOT points here and `templates/` sits
+  # right next to us (no gem root anymore).
+  ROOT ||= Pathname.new(__dir__)
+  VERSION ||= '0.2.0'
+
+  # Branches that select `.env` instead of `.env.staging`.
+  MAIN_BRANCHES ||= %w[master main]
+
+  # Server-side conventions. Not config-tunable because doctor and the
+  # deploy flow both hardcode these paths in the host setup. A different
+  # caddy/systemd layout means a different recipe.
+  PORT_RANGE  ||= (3010..3990).step(10).to_a
+  CADDY_SITES ||= '/etc/caddy/sites'
+  SYSTEMD_DIR ||= '/etc/systemd/system'
+
+  class Error < StandardError
+    def to_s
+      "ERROR: #{super}"
+    end
+  end
+
+  # Host-supplied defaults that sit under the user's .yaml. Set once by a
+  # wrapping plugin/Hammerfile (e.g. lux-fw seeds 'lux-web' / 'lux-apps'),
+  # consumed by Config.new. Empty by default so the recipe stays "generic".
+  @defaults = {}
+
+  class << self
+    attr_reader :defaults
+
+    def set_defaults(hash)
+      @defaults = (hash || {}).each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    end
+  end
+end
+
+require_relative 'config'
+require_relative 'ssh'
+require_relative 'template'
+require_relative 'doctor'
+require_relative 'context'
+require_relative 'manifest'
+require_relative 'commands'
+require_relative 'hammer'