legionio 1.6.7 → 1.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e025887526f8b9e258eb168a14a83d5c34e60668eadbe9e1ccd5c995e27d725c
-  data.tar.gz: a85e52dc5ec39293461e7df402f2ea8f1a410d293c28141fc935cfb6023b71df
+  metadata.gz: cd3587ed7997208005a0a8746aca477701811f8e506c1d8d9345a40d180317fc
+  data.tar.gz: e805096f6577c2b1317807d50beab27bbb91527e2a02807231596fbd6a1d91ca
 SHA512:
-  metadata.gz: 6ecefca3ab028b370f8e590cf4fa81290e3a9e106f53a5655d11928f40ec99a0d48451ab94c9516086fd81bd5c42d4523eae4d975b9df667d8db7010656884c6
-  data.tar.gz: c5f4aa31b5431e6fb012991fe0048ac75c0d25d95e6402983590d7954491ad53e78b18d2911cb7969427cd60e63a47975d7ca89ff7642857cd857328dec559e3
+  metadata.gz: 5d6c20753f9803fc34cd4bb577304bc31d708df54f9e49f266dbb32073c3d06835e2d625efbed610244b5888085d823222627fb07ad889c1ff85d37d028f603a
+  data.tar.gz: 0a1dbbff5e24580f3b8b97fb434c626f029f449501b138d0a29f9fcb0eb15edd05808c5b34353260a6bdc4808d4f747362d8f4e6e9f3afdd47362b56035c1e0f

data/CHANGELOG.md

@@ -1,27 +1,18 @@
 # Legion Changelog
 
-## [1.6.7] - 2026-03-26
-
-### Fixed
-- `setup_generated_functions` now runs only when `extensions: true` (inside the extensions gate) preventing unexpected boot side-effects in CLI flows that disable extensions
-- Consumer tag entropy upgraded from `SecureRandom.hex(4)` (32-bit) to `SecureRandom.uuid` (122-bit) in both `prepare` and `subscribe` paths of subscription actor, eliminating the theoretical RabbitMQ `NOT_ALLOWED` tag collision
-
-## [1.6.6] - 2026-03-26
+## [1.6.8] - 2026-03-26
 
 ### Added
 - `legionio bootstrap SOURCE` command: combines `config import`, `config scaffold`, and `setup agentic` into one command
 - Pre-flight checks for klist (Kerberos ticket), brew availability, and legionio binary
-- `--skip-packs` flag to skip gem pack installation (config-only mode)
-- `--start` flag to start redis + legionio via brew services after bootstrap
-- `--force` flag to overwrite existing config files during bootstrap
-- `--json` flag for machine-readable bootstrap output
-- `shell_capture` helper extracted to make shell invocations stubbable in specs
-- 62 specs covering preflight checks, pack extraction, config fetch/write delegation, pack install, summary output, all flags, and error handling
+- `--skip-packs`, `--start`, `--force`, `--json` flags for bootstrap command
+- Self-awareness system prompt enrichment: `Context.to_system_prompt` appends live metacognition self-narrative from `lex-agentic-self` when loaded; guarded with `defined?()` and `rescue StandardError`
 
-## [1.6.5] - 2026-03-26
+## [1.6.7] - 2026-03-26
 
-### Added
-- `Context.to_system_prompt` appends a live self-awareness section from `lex-agentic-self` Metacognition when the gem is loaded; logic extracted into `self_awareness_hint` helper to keep `to_system_prompt` within Metrics/CyclomaticComplexity limits; guarded with `defined?()` and `rescue StandardError`
+### Fixed
+- `setup_generated_functions` now runs only when `extensions: true` (inside the extensions gate) preventing unexpected boot side-effects in CLI flows that disable extensions
+- Consumer tag entropy upgraded from `SecureRandom.hex(4)` (32-bit) to `SecureRandom.uuid` (122-bit) in both `prepare` and `subscribe` paths of subscription actor, eliminating the theoretical RabbitMQ `NOT_ALLOWED` tag collision
 
 ## [1.6.4] - 2026-03-26
 

data/lib/legion/cli/bootstrap_command.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'json'
+require 'fileutils'
+require 'rbconfig'
+require 'thor'
+require 'legion/cli/output'
+
+module Legion
+  module CLI
+    class Bootstrap < Thor
+      namespace 'bootstrap'
+
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,       type: :boolean, default: false, desc: 'Machine-readable output'
+      class_option :no_color,   type: :boolean, default: false, desc: 'Disable color output'
+      class_option :skip_packs, type: :boolean, default: false, desc: 'Skip gem pack installation (config only)'
+      class_option :start,      type: :boolean, default: false, desc: 'Start redis + legionio via brew services after bootstrap'
+      class_option :force,      type: :boolean, default: false, desc: 'Overwrite existing config files'
+
+      desc 'SOURCE', 'Bootstrap Legion from a URL or local config file (fetch config, scaffold, install packs)'
+      long_desc <<~DESC
+        Combines three manual steps into one:
+
+          legionio config import SOURCE   (fetch + write config)
+          legionio config scaffold        (fill gaps with env-detected defaults)
+          legionio setup agentic          (install cognitive gem packs)
+
+        SOURCE may be an HTTPS URL or a local file path to a bootstrap JSON file.
+        The JSON may include a "packs" array (e.g. ["agentic"]) which controls which
+        gem packs are installed. That key is removed before the config is written.
+
+        Options:
+          --skip-packs   Skip gem pack installation entirely
+          --start        After bootstrap, run: brew services start redis && brew services start legionio
+          --force        Overwrite existing config files
+          --json         Machine-readable JSON output
+      DESC
+      def execute(source)
+        require_relative 'config_import'
+        require_relative 'config_scaffold'
+        require_relative 'setup_command'
+
+        out     = formatter
+        results = {}
+        warns   = []
+
+        # 1. Pre-flight checks
+        print_step(out, 'Pre-flight checks')
+        results[:preflight] = run_preflight_checks(out, warns)
+
+        # 2. Fetch + parse config
+        print_step(out, "Fetching config from #{source}")
+        body   = ConfigImport.fetch_source(source)
+        config = ConfigImport.parse_payload(body)
+
+        # 3. Extract packs before writing (bootstrap-only directive)
+        pack_names = Array(config.delete(:packs)).map(&:to_s).reject(&:empty?)
+        results[:packs_requested] = pack_names
+
+        # 4. Write config
+        path = ConfigImport.write_config(config, force: options[:force])
+        results[:config_written] = path
+        out.success("Config written to #{path}") unless options[:json]
+
+        # 5. Scaffold missing subsystem files
+        results[:scaffold] = run_scaffold(out)
+
+        # 6. Install packs (unless --skip-packs)
+        results[:packs_installed] = install_packs_step(pack_names, out)
+
+        # 7. Post-bootstrap summary
+        summary = build_summary(config, results, warns)
+        results[:summary] = summary
+        print_summary(out, summary)
+
+        # 8. Optional --start
+        if options[:start]
+          print_step(out, 'Starting services')
+          results[:services_started] = start_services(out)
+        end
+
+        out.json(results) if options[:json]
+      rescue CLI::Error => e
+        formatter.error(e.message)
+        raise SystemExit, 1
+      end
+
+      default_task :execute
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def print_step(out, message)
+          return if options[:json]
+
+          out.spacer
+          out.header(message)
+        end
+
+        # Wraps backtick execution, returning [output, success_bool].
+        # Extracted as a method so specs can stub it cleanly.
+        def shell_capture(cmd)
+          output = `#{cmd} 2>&1`
+          [output, $CHILD_STATUS.success?]
+        end
+
+        # -----------------------------------------------------------------------
+        # Pre-flight checks
+        # -----------------------------------------------------------------------
+
+        def run_preflight_checks(out, warns)
+          {
+            klist:    check_klist(out, warns),
+            brew:     check_brew(out, warns),
+            legionio: check_legionio_binary(out, warns)
+          }
+        end
+
+        def check_klist(out, warns)
+          output, success = shell_capture('klist')
+          if success && output.match?(/principal|Credentials/i)
+            out.success('Kerberos ticket valid') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'No valid Kerberos ticket found. Run `kinit` before bootstrapping.'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "klist check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def check_brew(out, warns)
+          _, success = shell_capture('brew --version')
+          if success
+            out.success('Homebrew available') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'Homebrew not found. Install from https://brew.sh'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "brew check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def check_legionio_binary(out, warns)
+          _, success = shell_capture('legionio version')
+          if success
+            out.success('legionio binary works') unless options[:json]
+            { status: :ok }
+          else
+            msg = 'legionio binary not responding. Try reinstalling: brew reinstall legionio'
+            warns << msg
+            out.warn(msg) unless options[:json]
+            { status: :warn, message: msg }
+          end
+        rescue StandardError => e
+          msg = "legionio binary check failed: #{e.message}"
+          warns << msg
+          out.warn(msg) unless options[:json]
+          { status: :warn, message: msg }
+        end
+
+        def run_scaffold(out)
+          print_step(out, 'Scaffolding missing subsystem files')
+          silent_out    = Output::Formatter.new(json: false, color: false)
+          scaffold_opts = build_scaffold_opts
+          scaffold_opts[:json] = false if options[:json]
+          ConfigScaffold.run(options[:json] ? silent_out : out, scaffold_opts)
+          :done
+        end
+
+        def install_packs_step(pack_names, out)
+          if options[:skip_packs]
+            out.warn('Skipping pack installation (--skip-packs)') unless options[:json]
+            []
+          else
+            print_step(out, "Installing packs: #{pack_names.join(', ')}") unless pack_names.empty?
+            install_packs(pack_names, out)
+          end
+        end
+
+        # -----------------------------------------------------------------------
+        # Scaffold options
+        # -----------------------------------------------------------------------
+
+        def build_scaffold_opts
+          {
+            force: options[:force],
+            json:  options[:json],
+            only:  options[:only],
+            full:  options[:full],
+            dir:   options[:dir]
+          }
+        end
+
+        # -----------------------------------------------------------------------
+        # Pack installation
+        # -----------------------------------------------------------------------
+
+        def install_packs(pack_names, out)
+          return [] if pack_names.empty?
+
+          gem_bin  = File.join(RbConfig::CONFIG['bindir'], 'gem')
+          results  = []
+
+          pack_names.each do |pack_name|
+            pack_sym = pack_name.to_sym
+            pack     = Setup::PACKS[pack_sym]
+            unless pack
+              out.warn("Unknown pack: #{pack_name} (valid: #{Setup::PACKS.keys.join(', ')})") unless options[:json]
+              next
+            end
+
+            out.header("Installing pack: #{pack_name}") unless options[:json]
+            gem_results = install_pack_gems(pack[:gems], gem_bin, out)
+            Gem::Specification.reset
+            results << { pack: pack_name, results: gem_results }
+          end
+
+          results
+        end
+
+        def install_pack_gems(gem_names, gem_bin, out)
+          already_installed = []
+          to_install        = []
+
+          gem_names.each do |name|
+            Gem::Specification.find_by_name(name)
+            already_installed << name
+          rescue Gem::MissingSpecError
+            to_install << name
+          end
+
+          gem_results = to_install.map { |g| install_single_gem(g, gem_bin, out) }
+
+          already_installed.each do |g|
+            out.success("  #{g} already installed") unless options[:json]
+          end
+
+          gem_results
+        end
+
+        def install_single_gem(name, gem_bin, out)
+          puts "  Installing #{name}..." unless options[:json]
+          output, success = shell_capture("#{gem_bin} install #{name} --no-document")
+          if success
+            out.success("  #{name} installed") unless options[:json]
+            { name: name, status: 'installed' }
+          else
+            out.error("  #{name} failed") unless options[:json]
+            { name: name, status: 'failed', error: output.strip.lines.last&.strip }
+          end
+        end
+
+        # -----------------------------------------------------------------------
+        # Summary
+        # -----------------------------------------------------------------------
+
+        def build_summary(config, results, warns)
+          settings_dir = ConfigImport::SETTINGS_DIR
+          subsystem_files = ConfigScaffold::SUBSYSTEMS.to_h do |s|
+            path = File.join(settings_dir, "#{s}.json")
+            [s, File.exist?(path)]
+          end
+
+          {
+            config_sections: config.keys.map(&:to_s),
+            packs_requested: results[:packs_requested] || [],
+            packs_installed: results[:packs_installed] || [],
+            subsystem_files: subsystem_files,
+            warnings:        warns,
+            preflight:       results[:preflight] || {}
+          }
+        end
+
+        def print_summary(out, summary)
+          return if options[:json]
+
+          out.spacer
+          out.header('Bootstrap Summary')
+          out.spacer
+
+          print_config_sections(summary)
+          print_subsystem_files(summary)
+          print_packs_summary(out, summary)
+          print_warnings_section(out, summary)
+          print_next_steps(out)
+        end
+
+        def print_config_sections(summary)
+          puts "  Config sections: #{summary[:config_sections].join(', ')}" if summary[:config_sections].any?
+        end
+
+        def print_subsystem_files(summary)
+          present = summary[:subsystem_files].select { |_, v| v }.keys
+          absent  = summary[:subsystem_files].reject { |_, v| v }.keys
+          puts "  Subsystem files present: #{present.join(', ')}" if present.any?
+          puts "  Subsystem files missing: #{absent.join(', ')}"  if absent.any?
+        end
+
+        def print_packs_summary(out, summary)
+          summary[:packs_installed].each do |pack_result|
+            successes = (pack_result[:results] || []).count { |r| r[:status] == 'installed' }
+            failures  = (pack_result[:results] || []).count { |r| r[:status] == 'failed' }
+            if failures.zero?
+              out.success("Pack #{pack_result[:pack]}: #{successes} gem(s) installed")
+            else
+              out.warn("Pack #{pack_result[:pack]}: #{successes} installed, #{failures} failed")
+            end
+          end
+          out.warn('Pack installation skipped') if options[:skip_packs]
+        end
+
+        def print_warnings_section(out, summary)
+          return unless summary[:warnings].any?
+
+          out.spacer
+          out.header('Attention')
+          summary[:warnings].each { |w| out.warn(w) }
+        end
+
+        def print_next_steps(out)
+          return if options[:start]
+
+          out.spacer
+          puts '  Next steps:'
+          puts '    brew services start redis && brew services start legionio'
+          puts '    legion'
+        end
+
+        # -----------------------------------------------------------------------
+        # Service startup (--start)
+        # -----------------------------------------------------------------------
+
+        def start_services(out)
+          redis_ok   = run_brew_service('redis', out)
+          legion_ok  = run_brew_service('legionio', out)
+          poll_daemon_ready(out) if redis_ok && legion_ok
+          { redis: redis_ok, legionio: legion_ok }
+        end
+
+        def run_brew_service(service, out)
+          output, success = shell_capture("brew services start #{service}")
+          if success
+            out.success("#{service} started") unless options[:json]
+            true
+          else
+            out.warn("#{service} failed to start: #{output.strip.lines.last&.strip}") unless options[:json]
+            false
+          end
+        rescue StandardError => e
+          out.warn("brew services start #{service} raised: #{e.message}") unless options[:json]
+          false
+        end
+
+        def poll_daemon_ready(out, port: 4567, timeout: 30)
+          require 'net/http'
+          deadline = ::Time.now + timeout
+          until ::Time.now > deadline
+            begin
+              resp = Net::HTTP.get_response(URI("http://localhost:#{port}/api/ready"))
+              if resp.is_a?(Net::HTTPSuccess)
+                out.success("Daemon ready on port #{port}") unless options[:json]
+                return true
+              end
+            rescue StandardError
+              # not ready yet — keep polling
+            end
+            sleep 1
+          end
+          out.warn("Daemon did not become ready within #{timeout}s") unless options[:json]
+          false
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat/context.rb

@@ -61,6 +61,7 @@ module Legion
           end
 
           parts << cognitive_awareness(directory)
+          parts << self_awareness_hint
 
           extra_dirs.each do |dir|
             expanded = File.expand_path(dir)
@@ -181,6 +182,16 @@ module Legion
           end
           nil
         end
+
+        def self.self_awareness_hint
+          return nil unless defined?(Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition)
+
+          result = Legion::Extensions::Agentic::Self::Metacognition::Runners::Metacognition.self_narrative
+          narrative = result[:prose] if result.is_a?(Hash) && result[:prose]
+          narrative ? "\nCurrent self-awareness:\n#{narrative}" : nil
+        rescue StandardError
+          nil
+        end
       end
     end
   end

data/lib/legion/cli.rb

@@ -65,6 +65,7 @@ module Legion
     autoload :Features,     'legion/cli/features_command'
     autoload :Debug,        'legion/cli/debug_command'
     autoload :CodegenCommand, 'legion/cli/codegen_command'
+    autoload :Bootstrap,      'legion/cli/bootstrap_command'
 
     module Groups
       autoload :Ai,       'legion/cli/groups/ai_group'
@@ -236,6 +237,9 @@ module Legion
       desc 'setup SUBCOMMAND', 'Install feature packs and configure IDE integrations'
       subcommand 'setup', Legion::CLI::Setup
 
+      desc 'bootstrap SOURCE', 'One-command setup: fetch config, scaffold, and install packs'
+      subcommand 'bootstrap', Legion::CLI::Bootstrap
+
       desc 'update', 'Update Legion gems to latest versions'
       subcommand 'update', Legion::CLI::Update
 

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.7'
+  VERSION = '1.6.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.7
+  version: 1.6.8
 platform: ruby
 authors:
 - Esity
@@ -512,6 +512,7 @@ files:
 - lib/legion/cli/apollo_command.rb
 - lib/legion/cli/audit_command.rb
 - lib/legion/cli/auth_command.rb
+- lib/legion/cli/bootstrap_command.rb
 - lib/legion/cli/chain.rb
 - lib/legion/cli/chain_command.rb
 - lib/legion/cli/chat/agent_delegator.rb