ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/register_auto_manager.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require 'git'
+require 'fileutils'
+
+module Ukiryu
+  # Manages automatic register cloning and updates
+  #
+  # This class handles:
+  # - Auto-cloning the register repository to ~/.ukiryu/register
+  # - Detecting development mode (local submodule)
+  # - Validating register integrity
+  # - Providing register path to the Register class
+  #
+  # @api private
+  class RegisterAutoManager
+    # GitHub repository URL for the register
+    REGISTER_URL = 'https://github.com/ukiryu/register'
+
+    # Default local directory for the register
+    DEFAULT_DIR = '~/.ukiryu/register'
+
+    class << self
+      # Get the register path, ensuring it exists
+      #
+      # Checks in order:
+      # 1. Environment variable UKIRYU_REGISTER
+      # 2. User's local clone (~/.ukiryu/register)
+      #
+      # @return [String, nil] the register path, or nil if unavailable
+      def register_path
+        # 1. Environment variable has highest priority
+        env_path = ENV['UKIRYU_REGISTER']
+        return env_path if env_path && Dir.exist?(env_path)
+
+        # 2. Use user's local clone, create if needed
+        ensure_user_clone
+      end
+
+      # Check if the register exists and is valid
+      #
+      # @return [Boolean] true if register exists and is valid
+      def register_exists?
+        path = resolve_register_path
+        return false unless path
+
+        Dir.exist?(path) && validate_register_integrity(path)
+      end
+
+      # Update or re-clone the register
+      #
+      # @param force [Boolean] if true, re-clone even if register exists
+      # @return [Boolean] true if successful
+      # @raise [RegisterError] if update fails
+      def update_register(force: false)
+        if force
+          force_reclone
+        else
+          update_existing_clone
+        end
+        true
+      rescue Git::GitExecuteError => e
+        raise RegisterError, "Failed to update register: #{e.message}"
+      rescue StandardError => e
+        raise RegisterError, "Register update failed: #{e.message}"
+      end
+
+      # Get register information
+      #
+      # @return [Hash] register information
+      def register_info
+        path = resolve_register_path
+        return { status: :not_found } unless path
+
+        return { status: :not_cloned, path: expand_path(DEFAULT_DIR) } unless Dir.exist?(path)
+
+        return { status: :invalid, path: path } unless validate_register_integrity(path)
+
+        info = {
+          status: :ok,
+          path: path,
+          source: detect_source(path)
+        }
+
+        # Add git info if available
+        git_dir = File.join(path, '.git')
+        if Dir.exist?(git_dir)
+          begin
+            g = Git.open(path)
+            info[:branch] = g.current_branch
+            log = g.log(1).execute
+            info[:commit] = log.first.sha[0..7]
+            info[:last_update] = Time.at(log.first.date.to_i)
+          rescue Git::GitExecuteError
+            # Git info not available, but register is valid
+          end
+        end
+
+        # Count available tools
+        tools_dir = File.join(path, 'tools')
+        info[:tools_count] = Dir.glob(File.join(tools_dir, '*')).select { |d| File.directory?(d) }.count if Dir.exist?(tools_dir)
+
+        info
+      end
+
+      private
+
+      # Ensure the user's local clone exists
+      #
+      # @return [String, nil] the register path, or nil if unavailable
+      def ensure_user_clone
+        expanded_path = expand_path(DEFAULT_DIR)
+
+        # If already exists and valid, return it
+        if Dir.exist?(expanded_path)
+          return expanded_path if validate_register_integrity(expanded_path)
+
+          # Exists but invalid, re-clone
+          force_reclone
+
+          return expanded_path
+        end
+
+        # Doesn't exist, clone it
+        clone_register(expanded_path)
+        expanded_path
+      rescue RegisterError
+        # Re-raise with context
+        raise
+      rescue StandardError => e
+        raise RegisterError, "Failed to setup register at #{expanded_path}: #{e.message}"
+      end
+
+      # Clone the register repository
+      #
+      # @param target_path [String] where to clone
+      # @raise [RegisterError] if clone fails
+      def clone_register(target_path)
+        parent_dir = File.dirname(target_path)
+
+        # Create parent directory if needed
+        FileUtils.mkdir_p(parent_dir) unless Dir.exist?(parent_dir)
+
+        # Check if git is available
+        unless git_available?
+          raise RegisterError, <<~ERROR
+            Git is required but not found in PATH.
+
+            To fix this:
+              1. Install git from https://git-scm.com
+              2. Or set UKIRYU_REGISTER to use a local register path
+
+            Example:
+              export UKIRYU_REGISTER=/path/to/register
+          ERROR
+        end
+
+        # Perform the clone
+        print "Cloning register from #{REGISTER_URL}..." if $stdout.tty?
+        Git.clone(REGISTER_URL, target_path, quiet: true)
+        puts 'done' if $stdout.tty?
+
+        # Validate the clone
+        unless validate_register_integrity(target_path)
+          FileUtils.rm_rf(target_path)
+          raise RegisterError, 'Register clone validation failed. Please try again or set UKIRYU_REGISTER.'
+        end
+      rescue Git::GitExecuteError => e
+        raise RegisterError, <<~ERROR
+          Failed to clone register from #{REGISTER_URL}: #{e.message}
+
+          To fix this:
+            1. Check your internet connection
+            2. Manually clone: git clone #{REGISTER_URL} #{target_path}
+            3. Or set UKIRYU_REGISTER to use a local register path
+
+          Example:
+            export UKIRYU_REGISTER=/path/to/register
+        ERROR
+      end
+
+      # Update existing register clone
+      #
+      # @raise [RegisterError] if update fails
+      def update_existing_clone
+        path = expand_path(DEFAULT_DIR)
+
+        return clone_register(path) unless Dir.exist?(path)
+
+        begin
+          print 'Updating register...' if $stdout.tty?
+          g = Git.open(path)
+          g.pull
+          puts 'done' if $stdout.tty?
+        rescue Git::GitExecuteError => e
+          raise RegisterError, "Failed to update register: #{e.message}"
+        end
+      end
+
+      # Force re-clone the register
+      #
+      # @raise [RegisterError] if re-clone fails
+      def force_reclone
+        path = expand_path(DEFAULT_DIR)
+        FileUtils.rm_rf(path) if Dir.exist?(path)
+        clone_register(path)
+      end
+
+      # Validate register integrity
+      #
+      # @param path [String] path to check
+      # @return [Boolean] true if valid
+      def validate_register_integrity(path)
+        return false unless path
+
+        # Check for tools/ directory
+        tools_dir = File.join(path, 'tools')
+        return false unless Dir.exist?(tools_dir)
+
+        # Check for at least one tool definition
+        # This confirms it's a valid register structure
+        Dir.glob(File.join(tools_dir, '*', '*.yaml')).any?
+      end
+
+      # Resolve the register path without auto-creating
+      #
+      # @return [String, nil] current register path or nil
+      def resolve_register_path
+        # Check environment variable
+        env_path = ENV['UKIRYU_REGISTER']
+        return env_path if env_path && Dir.exist?(env_path)
+
+        # Check user clone
+        expanded = expand_path(DEFAULT_DIR)
+        Dir.exist?(expanded) ? expanded : nil
+      end
+
+      # Detect the source of the register
+      #
+      # @param path [String] register path
+      # @return [Symbol] :env or :user
+      def detect_source(path)
+        env_path = ENV['UKIRYU_REGISTER']
+        return :env if env_path && path == File.expand_path(env_path)
+
+        :user
+      end
+
+      # Check if git is available
+      #
+      # @return [Boolean] true if git binary is available
+      def git_available?
+        system('git --version > /dev/null 2>&1')
+      end
+
+      # Expand a path with ~ support
+      #
+      # @param path [String] path to expand
+      # @return [String] expanded path
+      def expand_path(path)
+        File.expand_path(path)
+      end
+    end
+
+    # Register-specific error
+    class RegisterError < StandardError; end
+  end
+end

data/lib/ukiryu/schema_validator.rb

@@ -31,10 +31,14 @@ module Ukiryu
         schema = load_schema(options[:schema_path])
         return ['Failed to load schema'] unless schema
 
+        # Convert symbol keys to strings for JSON Schema validation
+        # JSON Schema validators expect string keys, but YAML.safe_load produces symbol keys
+        stringified_profile = stringify_keys(profile)
+
         # Validate against JSON schema
         begin
           # JSON Schema library expects the data to be a hash
-          validation_errors = JSON::Validator.fully_validate(schema, profile, strict: options[:strict] || false)
+          validation_errors = JSON::Validator.fully_validate(schema, stringified_profile, strict: options[:strict] || false)
 
           # Convert errors to readable format
           validation_errors.each do |error|
@@ -65,16 +69,10 @@ module Ukiryu
 
       # Get the default schema path
       #
-      # @return [String, nil] the default schema path
+      # @return [String, nil] the default schema path (from UKIRYU_SCHEMA_PATH env var)
       def default_schema_path
-        # Schema is in the sibling 'schema' directory at the same level as the gem
-        # From lib/ukiryu/, we go up to gem root, then to sibling schema/
-        gem_root = File.expand_path('../..', __dir__) # ukiryu gem root
-        schema_dir = File.expand_path('../schema', gem_root) # src/ukiryu/schema/
-        schema_file = File.join(schema_dir, 'tool-profile.schema.yaml')
-        return schema_file if File.exist?(schema_file)
-
-        nil
+        # Check environment variable for schema path
+        ENV['UKIRYU_SCHEMA_PATH']
       end
 
       private
@@ -96,6 +94,29 @@ module Ukiryu
       def format_schema_error(error)
         error
       end
+
+      # Convert symbol keys to strings for JSON Schema validation
+      #
+      # JSON Schema validators expect string keys in the data structure,
+      # but YAML.safe_load produces symbol keys. This method recursively
+      # converts all symbol keys to strings while preserving values.
+      #
+      # @param hash [Hash] the hash with symbol keys
+      # @return [Hash] hash with string keys
+      def stringify_keys(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.transform_keys(&:to_s).transform_values do |v|
+          case v
+          when Hash
+            stringify_keys(v)
+          when Array
+            v.map { |item| item.is_a?(Hash) ? stringify_keys(item) : item }
+          else
+            v
+          end
+        end
+      end
     end
   end
 end

data/lib/ukiryu/shell/base.rb

@@ -27,6 +27,24 @@ module Ukiryu
         raise NotImplementedError, "#{self.class} must implement #escape"
       end
 
+      # Check if a string needs quoting
+      # Strings with spaces, special chars, or empty strings need quoting
+      #
+      # @param string [String] the string to check
+      # @return [Boolean] true if quoting is needed
+      def needs_quoting?(string)
+        str = string.to_s
+        # Empty strings need quoting
+        return true if str.empty?
+        # Strings with whitespace need quoting
+        return true if str =~ /\s/
+        # Strings with shell special characters need quoting
+        # Common special chars: $ & * ( ) [ ] { } | ; < > ? ` ~ ! # @ % "
+        return true if str =~ /[\s&*()\[\]{}|;<>?`~!@%"]/
+
+        false
+      end
+
       # Quote an argument for this shell
       #
       # @param string [String] the string to quote

data/lib/ukiryu/shell/bash.rb

@@ -51,9 +51,27 @@ module Ukiryu
 
       # Get headless environment (disable DISPLAY on Unix)
       #
+      # For macOS, adds additional variables to prevent GUI initialization
+      # that can cause crashes in GUI applications like Inkscape.
+      #
       # @return [Hash] environment variables for headless operation
       def headless_environment
-        { 'DISPLAY' => '' }
+        require_relative '../platform'
+
+        env = {}
+
+        # Completely remove DISPLAY instead of setting to empty string
+        # This ensures full headless mode with no display connection
+        # The executor will exclude this key from the environment entirely
+
+        # Add macOS-specific environment variables to prevent GUI initialization
+        if Platform.detect == :macos
+          env['NSAppleEventsSuppressStartupAlert'] = 'true' # Suppress Apple Events
+          env['NSUIElement'] = '1' # Run as background agent
+          env['GDK_BACKEND'] = 'x11' # Force X11 backend (respects missing DISPLAY)
+        end
+
+        env
       end
     end
   end

data/lib/ukiryu/shell/cmd.rb

@@ -56,12 +56,22 @@ module Ukiryu
       end
 
       # Join executable and arguments into a command line
+      # Uses smart quoting: only quote arguments that need it
       #
       # @param executable [String] the executable path
       # @param args [Array<String>] the arguments
       # @return [String] the complete command line
       def join(executable, *args)
-        [executable, *args.map { |a| quote(a) }].join(' ')
+        args_formatted = args.map do |a|
+          if needs_quoting?(a)
+            quote(a)
+          else
+            # For simple strings, pass without quotes
+            # cmd.exe treats them as literal strings
+            escape(a)
+          end
+        end
+        [executable, *args_formatted].join(' ')
       end
 
       # cmd.exe doesn't need DISPLAY variable

data/lib/ukiryu/shell/powershell.rb

@@ -41,12 +41,22 @@ module Ukiryu
       end
 
       # Join executable and arguments into a command line
+      # Uses smart quoting: only quote arguments that need it
       #
       # @param executable [String] the executable path
       # @param args [Array<String>] the arguments
       # @return [String] the complete command line
       def join(executable, *args)
-        [executable, *args.map { |a| quote(a) }].join(' ')
+        args_formatted = args.map do |a|
+          if needs_quoting?(a)
+            quote(a)
+          else
+            # For simple strings, pass without quotes
+            # PowerShell treats them as literal strings
+            a
+          end
+        end
+        [executable, *args_formatted].join(' ')
       end
 
       # PowerShell doesn't need DISPLAY variable

data/lib/ukiryu/shell.rb

@@ -73,7 +73,7 @@ module Ukiryu
         when :powershell
           powershell_available?
         when :cmd
-          true # cmd is always available on Windows
+          Platform.windows? # cmd is only available on Windows
         else
           false
         end