dotfiles-tui 0.0.5

data/Hooks/core/lib/display.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Bootstrap
+  module Display
+    module_function
+
+    def header(text)
+      width = 80 # Fixed width as requested
+      text_len = text.length
+      padding = [(width - text_len - 2) / 2, 0].max
+      
+      # Double border style
+      top_border = "╔#{'═' * width}╗"
+      bottom_border = "╚#{'═' * width}╝"
+      
+      left_pad_len = padding
+      right_pad_len = width - text_len - left_pad_len
+      
+      left_pad = ' ' * left_pad_len
+      right_pad = ' ' * right_pad_len
+      
+      # Cyan border, Bold White text
+      content = "║#{left_pad}\e[1;37m#{text}\e[0m#{right_pad}║"
+
+      puts
+      puts "  \e[0;36m#{top_border}\e[0m"
+      puts "  \e[0;36m#{content}\e[0m"
+      puts "  \e[0;36m#{bottom_border}\e[0m"
+      puts
+    end
+
+    def info(message)
+      # Log to file
+      Bootstrap::Logger.log(message)
+      # Transient output to terminal
+      transient(message)
+    end
+    
+    def transient(message)
+      # Clear line and print message
+      # \r moves to beginning of line
+      # \e[K clears from cursor to end of line
+      print "\r\e[K  [ \e[0;34m🚀\e[0m ] #{message}"
+      $stdout.flush
+    end
+
+    def persist(message, status = :success)
+      # Make the current line permanent with a status
+      # \r moves to beginning
+      # \e[K clears line
+      
+      case status
+      when :success
+        # Transient success: overwrite the line
+        print "\r\e[K  [ \e[0;32m✔\e[0m ] #{message}"
+        $stdout.flush
+      when :error
+        # Errors persist
+        puts "\r\e[K  [\e[0;31m✖\e[0m] #{message}"
+      when :warn
+        # Warnings persist
+        puts "\r\e[K  [\e[0;33m⚠\e[0m] #{message}"
+      end
+    end
+
+    def user(message)
+      puts("[ \e[0;33m??\e[0m ] #{message}")
+    end
+
+    def success(message)
+      Bootstrap::Logger.log("SUCCESS: #{message}")
+      persist(message, :success)
+    end
+
+    def warn(message)
+      Bootstrap::Logger.log("WARNING: #{message}")
+      persist(message, :warn)
+    end
+
+    def fail(message)
+      Bootstrap::Logger.error(message)
+      persist(message, :error)
+      exit(1)
+    end
+
+    def wait_for_confirmation(prompt: "\nPress (y/Y) when ready:")
+      print("#{prompt} ")
+      loop do
+        char = read_single_character
+        return true if %w[y Y].include?(char)
+
+        print("\nInvalid choice: #{char}. #{prompt} ")
+      end
+    ensure
+      puts
+    end
+
+
+
+    def console_width
+      IO.console.winsize[1]
+    rescue StandardError
+      120
+    end
+
+    def read_single_character
+      char = nil
+      begin
+        system('stty raw -echo')
+        char = STDIN.getc
+      ensure
+        system('stty -raw echo')
+      end
+      char.chr
+    end
+  end
+end
+

data/Hooks/core/lib/hook_config.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'yaml'
+
+require_relative 'display'
+
+module Bootstrap
+  class HookConfig
+    include Singleton
+
+    CONFIG_FILE = File.expand_path('../../../config/hooks.yml', __dir__)
+
+    def initialize
+      @data = load_file
+      @only = parse_env_list(ENV.fetch('BOOTSTRAP_ONLY', nil))
+      @exclude = parse_env_list(ENV.fetch('BOOTSTRAP_EXCLUDE', nil))
+    end
+
+    def skipped?(name, stage)
+      stage = stage.to_sym
+
+      if @only.any?
+        return !@only.fetch(name, {}).fetch(stage, false)
+      end
+
+      excluded_by_env?(name, stage) || excluded_by_config?(name, stage)
+    end
+
+    def reason_for_skip(name, stage)
+      stage = stage.to_sym
+
+      if @only.any? && !@only.fetch(name, {}).fetch(stage, false)
+        return 'not included in BOOTSTRAP_ONLY'
+      end
+      return 'listed in BOOTSTRAP_EXCLUDE' if excluded_by_env?(name, stage)
+      return 'disabled in config/hooks.yml' if excluded_by_config?(name, stage)
+
+      nil
+    end
+
+    private
+
+    def excluded_by_env?(name, stage)
+      entry = @exclude[name] || @exclude[name.to_sym]
+      return false if entry.nil?
+
+      entry.fetch(stage, true)
+    end
+
+    def excluded_by_config?(name, stage)
+      excluded = @data.fetch('excluded_hooks', {})
+      value = excluded[name] || excluded[name.to_s] || excluded[name.to_sym]
+      case value
+      when Hash
+        normalize_hash(value).fetch(stage, false)
+      when Array
+        value.map!(&:to_s)
+        value.include?(stage.to_s)
+      when true
+        true
+      else
+        false
+      end
+    end
+
+    def parse_env_list(raw)
+      return {} if raw.nil? || raw.strip.empty?
+
+      raw.split(',').each_with_object(Hash.new { |h, k| h[k] = {} }) do |entry, acc|
+        hook, stage = entry.strip.split(':', 2)
+        next if hook.nil? || hook.empty?
+
+        if stage.nil?
+          acc[hook][:'pre'] = true
+          acc[hook][:'post'] = true
+        else
+          acc[hook][stage.to_sym] = true
+        end
+      end
+    end
+
+    def normalize_hash(hash)
+      hash.transform_keys(&:to_sym)
+    end
+
+    def load_file
+      return {} unless File.exist?(CONFIG_FILE)
+
+      YAML.safe_load(File.read(CONFIG_FILE)) || {}
+    rescue Psych::SyntaxError => e
+      Bootstrap::Display.warn("Invalid YAML in #{CONFIG_FILE}: #{e.message}")
+      {}
+    end
+  end
+end

data/Hooks/core/lib/hook_context.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative 'display'
+require_relative 'system'
+
+module Bootstrap
+  class HookContext
+    include FileUtils
+
+    attr_reader :name, :stage
+    attr_accessor :configurator
+
+    def initialize(name:, stage:, configurator: nil)
+      @name = name
+      @stage = stage.to_sym
+      @configurator = configurator
+    end
+
+    def header(message)
+      Bootstrap::Display.header(message)
+    end
+
+    def info(message)
+      Bootstrap::Display.info(message)
+    end
+
+    def warn(message)
+      Bootstrap::Display.warn(message)
+    end
+
+    def success(message)
+      Bootstrap::Display.success(message)
+    end
+
+    def fail(message)
+      Bootstrap::Display.fail(message)
+    end
+
+    def run(command, allow_failure: false, env: {})
+      # Optimization: Check if package is already installed
+      if command.is_a?(String) && command.start_with?('/opt/homebrew/bin/brew install')
+        if command.include?('--formula')
+          formula = command.match(/--formula\s+([^\s]+)/)&.captures&.first
+          if formula && @configurator&.formula_installed?(formula)
+            Bootstrap::Logger.log("Skipping #{formula} (already installed)")
+            return true
+          end
+        elsif command.include?('--cask')
+          cask = command.match(/--cask\s+([^\s]+)/)&.captures&.first
+          if cask && @configurator&.cask_installed?(cask)
+            Bootstrap::Logger.log("Skipping #{cask} (already installed)")
+            return true
+          end
+        end
+      end
+
+      Bootstrap::System.run(command, allow_failure: allow_failure, env: env, dry_run: dry_run?, quiet: @configurator&.quiet)
+    end
+
+    def run!(command, env: {})
+      Bootstrap::System.run!(command, env: env, dry_run: dry_run?, quiet: @configurator&.quiet)
+    end
+
+    def home_path(*segments)
+      File.join(Dir.home, *segments)
+    end
+
+    def scripts_root
+      ENV.fetch('SCRIPT_DIR', File.expand_path('../../..', __dir__))
+    end
+
+    def hooks_root
+      ENV.fetch('HOOKS_DIR', File.join(scripts_root, 'Hooks'))
+    end
+
+    def configs_root
+      ENV.fetch('CONFIGS_DIR', File.join(scripts_root, 'Configs'))
+    end
+
+    def hook_path(*segments)
+      File.join(hooks_root, name, *segments)
+    end
+
+    def ensure_directory(path)
+      return if dry_run?
+      FileUtils.mkdir_p(path)
+    end
+
+    def remove_path(path)
+      if dry_run?
+        Bootstrap::Display.info("[DRY-RUN] Removing #{path}")
+        return
+      end
+
+      if File.directory?(path)
+        FileUtils.rm_rf(path)
+      else
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def copy(source, destination)
+      if dry_run?
+        Bootstrap::Display.info("[DRY-RUN] Copying #{source} to #{destination}")
+        return
+      end
+
+      if File.directory?(source)
+        FileUtils.cp_r(source, destination)
+      else
+        ensure_directory(File.dirname(destination))
+        FileUtils.cp(source, destination)
+      end
+    end
+
+    private
+
+    def dry_run?
+      @configurator&.dry_run
+    end
+  end
+end

data/Hooks/core/lib/hooks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'display'
+require_relative 'hook_config'
+require_relative 'hook_context'
+
+module Bootstrap
+  module Hooks
+    module_function
+
+    def run(name, stage:, configurator: current_configurator)
+      stage = stage.to_sym
+      config = Bootstrap::HookConfig.instance
+
+      if config.skipped?(name, stage)
+        reason = config.reason_for_skip(name, stage)
+        Bootstrap::Display.info("Skipping #{name} #{stage} hook (#{reason})")
+        return
+      end
+
+      context = Bootstrap::HookContext.new(name: name, stage: stage, configurator: configurator)
+      yield context
+      Bootstrap::Display.success("#{name} #{stage} hook complete")
+    rescue StandardError => e
+      Bootstrap::Display.fail("#{name} #{stage} hook failed: #{e.message}")
+      raise
+    end
+
+    def with_configurator(configurator)
+      previous = current_configurator
+      self.current_configurator = configurator
+      yield
+    ensure
+      self.current_configurator = previous
+    end
+
+    def current_configurator
+      Thread.current[:bootstrap_current_configurator]
+    end
+
+    def current_configurator=(configurator)
+      Thread.current[:bootstrap_current_configurator] = configurator
+    end
+  end
+end

data/Hooks/core/lib/logger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Bootstrap
+  class Logger
+    LOG_FILE = 'install.log'
+
+    class << self
+      def init
+        File.write(LOG_FILE, "Bootstrap Log - #{Time.now}\n========================================\n\n")
+      end
+
+      def log(message)
+        File.open(LOG_FILE, 'a') do |f|
+          f.puts("[#{Time.now.strftime('%H:%M:%S')}] #{message}")
+        end
+      end
+
+      def error(message)
+        log("ERROR: #{message}")
+      end
+    end
+  end
+end

data/Hooks/core/lib/menu.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Bootstrap
+  class Menu
+    def initialize(options)
+      @options = options
+      @selected_index = 0
+    end
+
+    def show
+      print "\e[?25l" # Hide cursor
+      loop do
+        render
+        key = read_key
+        case key
+        when :up
+          @selected_index = (@selected_index - 1) % @options.size
+        when :down
+          @selected_index = (@selected_index + 1) % @options.size
+        when :enter
+          print "\e[?25h" # Show cursor
+          # Clear the menu
+          # Move up by options size + 2 (header + spacing)
+          print "\e[#{@options.size + 2}A"
+          print "\e[J" # Clear from cursor to end of screen
+          return @options[@selected_index][:value]
+        when :ctrl_c, :q
+          print "\e[?25h" # Show cursor
+          puts "\nExiting..."
+          exit
+        end
+      end
+    ensure
+      print "\e[?25h" # Ensure cursor is shown on exit
+    end
+
+    private
+
+    def render
+      # Move cursor up by the number of options to overwrite
+      print "\e[#{@options.size + 2}A" if @rendered_once
+      @rendered_once = true
+
+      puts "\n  \e[1;34mSelect an action (Use Arrow Keys):\e[0m"
+      @options.each_with_index do |option, index|
+        prefix = index == @selected_index ? "\e[1;32m> \e[0m" : "  "
+        label = index == @selected_index ? "\e[1;32m#{option[:label]}\e[0m" : option[:label]
+        puts "  #{prefix}#{label}"
+      end
+    end
+
+    def read_key
+      char = STDIN.getch
+      if char == "\e"
+        char << STDIN.read_nonblock(3) rescue nil
+        char << STDIN.read_nonblock(2) rescue nil
+      end
+
+      case char
+      when "\e[A", "k" then :up
+      when "\e[B", "j" then :down
+      when "\r", "\n" then :enter
+      when "\u0003", "q" then :ctrl_c
+      else :unknown
+      end
+    end
+  end
+end

data/Hooks/core/lib/spinner.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'display'
+
+module Bootstrap
+  class Spinner
+    FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+    INTERVAL = 0.1
+
+    def self.spin(message)
+      spinner = new(message)
+      spinner.start
+      begin
+        yield spinner
+      ensure
+        spinner.stop
+      end
+    end
+
+    def initialize(message)
+      @message = message
+      @stop = false
+      @mutex = Mutex.new
+    end
+
+    def update(message)
+      @mutex.synchronize { @message = message }
+    end
+
+    def start
+      @thread = Thread.new do
+        i = 0
+        loop do
+          break if @stop
+          frame = FRAMES[i % FRAMES.length]
+          msg = @mutex.synchronize { @message }
+          print "\r\e[K  [ \e[1;34m#{frame}\e[0m ] #{msg}"
+          i += 1
+          sleep INTERVAL
+        end
+      end
+    end
+
+    def stop
+      @stop = true
+      @thread.join if @thread
+      print "\r\e[K"
+    end
+  end
+end

data/Hooks/core/lib/system.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+require_relative 'display'
+
+module Bootstrap
+  module System
+    module_function
+
+    def run(command, allow_failure: false, env: {}, dry_run: false, quiet: false)
+      cmd_str = command.is_a?(Array) ? command.join(' ') : command
+      
+      if dry_run
+        # Transient output for dry-run as requested
+        # If quiet, we don't print even in dry run? 
+        # Actually, in dry run we usually want to see what's happening.
+        # But if spinner is active, spinner shows "Installing X".
+        # We don't need "Running: brew install X".
+        # So yes, respect quiet.
+        unless quiet
+          Bootstrap::Display.transient("[DRY-RUN] #{cmd_str}")
+        end
+        # Log it
+        Bootstrap::Logger.log("[DRY-RUN] #{cmd_str}")
+        return true
+      end
+
+      unless quiet
+        Bootstrap::Display.transient("Running: #{cmd_str}...")
+      end
+      Bootstrap::Logger.log("EXEC: #{cmd_str}")
+
+      status = nil
+      args = [env]
+      if command.is_a?(Array)
+        args.concat(command)
+      else
+        args.push(command)
+      end
+
+      output_buffer = ""
+      
+      # Capture output and log it, but don't print to terminal unless error
+      Open3.popen2e(*args) do |_stdin, stdout_err, wait_thread|
+        stdout_err.each do |line|
+          output_buffer += line
+          Bootstrap::Logger.log("  > #{line.strip}")
+        end
+        status = wait_thread.value
+      end
+
+      if status.success?
+        # Success: Log it, but do NOT persist to terminal.
+        # This ensures the "next line should clear the same line" behavior.
+        Bootstrap::Logger.log("COMPLETED: #{cmd_str}")
+        return true
+      end
+
+      message = "Command failed (#{status.exitstatus}): #{cmd_str}"
+      Bootstrap::Logger.error(message)
+      Bootstrap::Logger.error("Output:\n#{output_buffer}")
+      
+      allow_failure ? Bootstrap::Display.warn(message) : raise(message)
+    end
+
+    def run!(command, env: {}, dry_run: false, quiet: false)
+      run(command, allow_failure: false, env: env, dry_run: dry_run, quiet: quiet)
+    end
+
+    def run_script(path, env: {})
+      raise "Script not found: #{path}" unless File.exist?(path)
+
+      run!("bash #{Shellwords.escape(path)}", env: env)
+    end
+  end
+end

data/Hooks/core/lib/tweaks.rb

@@ -0,0 +1,59 @@
+module Tweaks
+
+  # Helper for writing defaults
+  def write_defaults(domain, key, value)
+    execute("defaults write #{domain} #{key} #{value}")
+  end
+
+
+  module HomebrewTweaks
+    def self.apply
+      execute("brew analytics off")
+    end
+  end
+
+  module FinderTweaks
+    def self.apply
+      write_defaults("NSGlobalDomain", "AppleShowAllExtensions", "true")
+      execute("chflags nohidden ~/Library")
+      execute("defaults write com.apple.finder ShowPathbar -bool true")
+    end
+  end
+
+  module DockTweaks
+    def self.apply
+      write_defaults("com.apple.dock", "autohide", "true")
+      write_defaults("com.apple.dock", "tilesize", "48")
+      write_defaults("com.apple.dock", "mineffect", '"suck"')
+    end
+  end
+
+  module KeyboardMouseTweaks
+    def self.apply
+      write_defaults("NSGlobalDomain", "KeyRepeat", "2")
+      write_defaults("NSGlobalDomain", "InitialKeyRepeat", "15")
+      write_defaults("-g", "com.apple.trackpad.scaling", "1")
+    end
+  end
+
+  module TerminalTweaks
+    def self.apply
+      write_defaults("com.apple.terminal", "StringEncodings", "-array 4")
+      write_defaults("com.apple.Terminal", "FocusFollowsMouse", "true")
+    end
+  end
+
+  def tweak_macOS_configuration
+    HomebrewTweaks.apply
+    FinderTweaks.apply
+    DockTweaks.apply
+    KeyboardMouseTweaks.apply
+    TerminalTweaks.apply
+    # Add more categories here as needed
+  end
+
+  def run_tweaks(modules)
+    modules.each { |mod| mod.apply }
+  end
+
+end

data/Hooks/core/library.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'lib/configurator'

data/Hooks/core/pre.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../core/common'
+require_relative '../core/library'
+
+Bootstrap::Hooks.run('core', stage: :pre) do |hook|
+  configurator = hook.configurator || Bootstrap::Configurator.new
+
+  Bootstrap::Display.header("Adding user #{ENV.fetch('USER', 'unknown')} to sudoers")
+  configurator.add_to_sudoers
+
+  configurator.set_system_hostname
+
+  Bootstrap::Display.header('Setting up Python environment (uv)')
+  configurator.setup_uv
+end
+

data/Hooks/ctrld/pre.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../core/common'
+
+Bootstrap::Hooks.run('ctrld', stage: :pre) do |_hook|
+  # No actions defined. Enable this hook via config/hooks.yml when needed.
+end