ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/cli_commands/lint_command.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../definition/definition_linter'
+
+module Ukiryu
+  module CliCommands
+    # Lint tool definitions for best practices
+    #
+    # The lint command checks tool definitions for best practices,
+    # deprecated patterns, and potential issues.
+    class LintCommand < Thor
+      class_option :verbose, type: :boolean, default: false
+      class_option :format, type: :string, default: 'text', enum: %w[text json]
+      class_option :severity, type: :string, enum: %w[error warning info style], desc: 'Minimum severity level'
+
+      desc 'file PATH', 'Lint a definition file'
+      def file(path)
+        lint_file(path)
+      end
+
+      desc 'all', 'Lint all definitions in register'
+      option :register, type: :string, desc: 'Register path'
+      def all
+        lint_all
+      end
+
+      desc 'rules', 'List all linting rules'
+      def rules
+        list_rules
+      end
+
+      private
+
+      # Lint a single file
+      #
+      # @param path [String] file path
+      def lint_file(path)
+        result = Ukiryu::Definition::DefinitionLinter.lint_file(path)
+
+        output_result(result, path)
+
+        # Exit with error if there are errors
+        exit 1 if result.has_errors?
+      end
+
+      # Lint all definitions in register
+      def lint_all
+        register_path = options[:register] || Ukiryu::Register.default_register_path
+        return say_error("Register not found: #{register_path}") unless Dir.exist?(register_path)
+
+        tools_dir = File.join(register_path, 'tools')
+        return say_error("Tools directory not found: #{tools_dir}") unless Dir.exist?(tools_dir)
+
+        results = {}
+        total_issues = 0
+
+        Dir.glob(File.join(tools_dir, '*', '*', '*.yaml')).each do |file|
+          result = Ukiryu::Definition::DefinitionLinter.lint_file(file)
+          results[file] = result
+          total_issues += result.count
+        end
+
+        # Summary
+        total_files = results.length
+        total_errors = results.values.sum(&:error_count)
+        total_warnings = results.values.sum { |r| r.count_by_severity(Ukiryu::Definition::LintIssue::SEVERITY_WARNING) }
+
+        say "\nLint Summary:", :cyan
+        say "  Files: #{total_files}", :white
+        say "  Issues: #{total_issues}", total_issues.zero? ? :green : :white
+        say "  Errors: #{total_errors}", total_errors.zero? ? :green : :red
+        say "  Warnings: #{total_warnings}", :white
+
+        # Show files with issues
+        if total_issues.positive?
+          say '', :clear
+          say 'Files with Issues:', :yellow
+
+          results.each do |file, result|
+            next unless result.has_issues?
+
+            status = result.has_errors? ? '✗' : '⚠'
+            say "  #{status} #{file} (#{result.count} issues)", :white
+          end
+        end
+
+        exit 1 if total_errors.positive?
+      end
+
+      # List all linting rules
+      def list_rules
+        say 'Linting Rules:', :cyan
+        say '', :clear
+
+        say 'Naming Convention Rules:', :white
+        say '  naming_tool_name_format - Tool name format', :dim
+        say '  naming_command_name_format - Command name format', :dim
+        say '', :clear
+
+        say 'Completeness Rules:', :white
+        say '  complete_missing_description - Missing description', :dim
+        say '  complete_missing_homepage - Missing homepage', :dim
+        say '  complete_missing_version_detection - Missing version detection', :dim
+        say '', :clear
+
+        say 'Security Rules:', :white
+        say '  security_suspicious_subcommand - Dangerous shell commands', :dim
+        say '  security_unvalidated_input - Arguments without type validation', :dim
+        say '', :clear
+
+        say 'Best Practice Rules:', :white
+        say '  style_redundant_default_profile - Redundant default profile', :dim
+        say '  complete_missing_platforms - Missing platforms specification', :dim
+      end
+
+      # Output linting result
+      #
+      # @param result [LintResult] linting result
+      # @param source [String] source identifier
+      def output_result(result, source)
+        case options[:format]
+        when 'json'
+          say result.to_h.to_json, :white
+        else
+          output_text(result, source)
+        end
+      end
+
+      # Output as text
+      #
+      # @param result [LintResult] linting result
+      # @param source [String] source identifier
+      def output_text(result, source)
+        say "Linting: #{source}", :cyan
+
+        if result.has_issues?
+          say "\nFound #{result.count} issue(s):", :yellow
+
+          {
+            Ukiryu::Definition::LintIssue::SEVERITY_ERROR => 'Errors',
+            Ukiryu::Definition::LintIssue::SEVERITY_WARNING => 'Warnings',
+            Ukiryu::Definition::LintIssue::SEVERITY_INFO => 'Info',
+            Ukiryu::Definition::LintIssue::SEVERITY_STYLE => 'Style'
+          }.each do |severity, label|
+            issues = result.by_severity(severity)
+            next if issues.empty?
+
+            say '', :clear
+            say "#{label}:", severity == :error ? :red : :white
+            issues.each { |issue| say "  #{issue}", :white }
+          end
+        else
+          say "\n✓ No issues found", :green
+        end
+      end
+
+      # Show error message
+      #
+      # @param message [String] error message
+      def say_error(message)
+        say message, :red
+        exit 1
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/list_command.rb

@@ -2,18 +2,18 @@
 
 require_relative 'base_command'
 require_relative '../tool'
-require_relative '../registry'
+require_relative '../register'
 
 module Ukiryu
   module CliCommands
-    # List all available tools in the registry
+    # List all available tools in the register
     class ListCommand < BaseCommand
       # Execute the list command
       def run
-        setup_registry
+        setup_register
 
-        tools = Registry.tools
-        error! 'No tools found in registry' if tools.empty?
+        tools = Register.tools
+        error! 'No tools found in register' if tools.empty?
 
         say "Available tools (#{tools.count}):", :cyan
 
@@ -22,7 +22,7 @@ module Ukiryu
         standalone_tools = []
 
         tools.sort.each do |name|
-          metadata = Registry.load_tool_metadata(name.to_sym)
+          metadata = Register.load_tool_metadata(name.to_sym)
 
           if metadata&.implements
             # This tool implements an interface

data/lib/ukiryu/cli_commands/opts_command.rb

@@ -12,11 +12,11 @@ module Ukiryu
       # @param tool_name [String] the tool name
       # @param command_name [String, nil] optional command name
       def run(tool_name, command_name = nil)
-        setup_registry
+        setup_register
 
         # Use find_by for interface-based discovery (ping -> ping_bsd/ping_gnu)
         tool = Tool.find_by(tool_name.to_sym)
-        error!("Tool not found: #{tool_name}\nAvailable tools: #{Registry.tools.sort.join(', ')}") unless tool
+        error!("Tool not found: #{tool_name}\nAvailable tools: #{Register.tools.sort.join(', ')}") unless tool
 
         tool_commands = tool.commands
         error! "No commands defined for #{tool_name}" unless tool_commands

data/lib/ukiryu/cli_commands/opts_command.rb.fixed

@@ -12,7 +12,7 @@ module Ukiryu
         # @param tool_name [String] the tool name
         # @param command_name [String, nil] optional command name
       def run(tool_name, command_name = nil)
-          setup_registry
+          setup_register
 
           tool = Tool.get(tool_name)
           tool_commands = tool.commands

data/lib/ukiryu/cli_commands/register_command.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../register_auto_manager'
+require_relative '../register'
+
+module Ukiryu
+  module CliCommands
+    # Command to manage the register
+    class RegisterCommand < BaseCommand
+      # Run the register command
+      #
+      # @param subcommand [String, nil] the subcommand (info, update, etc.)
+      # @param options [Hash] command options
+      # @option options [Boolean] :force force re-clone
+      # @option options [Boolean] :verbose show verbose output
+      def run(subcommand = nil, options = {})
+        case subcommand
+        when 'info', nil
+          show_info(options)
+        when 'update'
+          update_register(options)
+        when 'path'
+          show_path
+        else
+          error!("Unknown subcommand: #{subcommand}. Valid subcommands: info, update, path")
+        end
+      rescue RegisterAutoManager::RegisterError => e
+        error!("Register error: #{e.message}")
+      end
+
+      private
+
+      # Show register information
+      #
+      # @param options [Hash] command options
+      def show_info(_options = {})
+        info = RegisterAutoManager.register_info
+
+        say 'Register Information', :cyan
+        say ''
+
+        case info[:status]
+        when :not_found
+          say '  Status: Not configured', :red
+          say ''
+          say '  No register found. Run: ukiryu register update', :yellow
+        when :not_cloned
+          say '  Status: Not cloned', :yellow
+          say "  Expected path: #{info[:path]}", :dim
+          say ''
+          say '  Run: ukiryu register update', :yellow
+        when :invalid
+          say '  Status: Invalid', :red
+          say "  Path: #{info[:path]}", :dim
+          say ''
+          say '  Register is corrupted. Run: ukiryu register update --force', :yellow
+        when :ok
+          say '  Status: OK', :green
+          say "  Path: #{info[:path]}", :dim
+          say "  Source: #{format_source(info[:source])}", :dim
+
+          say "  Tools available: #{info[:tools_count]}", :dim if info[:tools_count]
+
+          say "  Branch: #{info[:branch]}", :dim if info[:branch]
+
+          say "  Commit: #{info[:commit]}", :dim if info[:commit]
+
+          say "  Last updated: #{info[:last_update].strftime('%Y-%m-%d %H:%M:%S')}", :dim if info[:last_update]
+        end
+
+        say ''
+        say 'Environment variable:', :cyan
+        env_path = ENV['UKIRYU_REGISTER']
+        if env_path
+          say "  UKIRYU_REGISTER=#{env_path}", :dim
+        else
+          say '  UKIRYU_REGISTER (not set)', :dim
+        end
+
+        show_manual_setup_help if info[:status] != :ok
+      end
+
+      # Update the register
+      #
+      # @param options [Hash] command options
+      def update_register(options = {})
+        force = options[:force] || false
+
+        if force
+          say 'Force re-cloning register...', :yellow
+        else
+          say 'Updating register...', :cyan
+        end
+
+        RegisterAutoManager.update_register(force: force)
+
+        say 'Register updated successfully!', :green
+        show_info(options)
+      end
+
+      # Show the register path
+      def show_path
+        path = RegisterAutoManager.register_path
+
+        if path
+          say path
+        else
+          error!('Register not available. Run: ukiryu register update')
+        end
+      end
+
+      # Format the source for display
+      #
+      # @param source [Symbol] the source symbol
+      # @return [String] formatted source
+      def format_source(source)
+        case source
+        when :env
+          'Environment variable (UKIRYU_REGISTER)'
+        when :dev
+          'Development mode (local submodule)'
+        when :user
+          'User local clone (~/.ukiryu/register)'
+        else
+          source.to_s
+        end
+      end
+
+      # Show manual setup help
+      def show_manual_setup_help
+        say ''
+        say 'Manual setup:', :cyan
+        say ''
+        say '  1. Clone the register:'
+        say "     git clone #{RegisterAutoManager::REGISTER_URL} ~/.ukiryu/register"
+        say ''
+        say '  2. Or set environment variable:'
+        say '     export UKIRYU_REGISTER=/path/to/register'
+        say ''
+        say '  3. Then run this command again.'
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/resolve_command.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../definition/discovery'
+require_relative '../definition/version_resolver'
+
+module Ukiryu
+  module CliCommands
+    # Resolve tool definitions
+    #
+    # The resolve command shows which definition would be used for a tool.
+    class ResolveCommand < BaseCommand
+      # Execute the resolve command
+      #
+      # @param tool_name [String] the tool name to resolve
+      # @param version_constraint [String, nil] optional version constraint
+      def run(tool_name, version_constraint = nil)
+        if tool_name.nil?
+          say 'Error: Tool name is required', :red
+          say '', :clear
+          say 'Usage: ukiryu resolve TOOL [VERSION_CONSTRAINT]', :white
+          exit 1
+        end
+
+        # Resolve the definition
+        resolve_definition(tool_name, version_constraint)
+      end
+
+      private
+
+      # Resolve which definition would be used
+      #
+      # @param tool_name [String] the tool name
+      # @param version_constraint [String, nil] optional version constraint
+      def resolve_definition(tool_name, version_constraint)
+        # Get all available definitions for the tool
+        definitions = Ukiryu::Definition::Discovery.definitions_for(tool_name)
+
+        if definitions.empty?
+          say "Resolution for: #{tool_name}", :cyan
+          say '', :clear
+          say "✗ No definitions found for '#{tool_name}'", :red
+          say '', :clear
+          say 'To see available tools:', :cyan
+          say '  ukiryu list', :white
+          say '', :clear
+          say 'To search for definitions:', :cyan
+          say '  ukiryu definitions list', :white
+          exit 1
+        end
+
+        say "Resolution for: #{tool_name}", :cyan
+        say '', :clear
+
+        # Show all available definitions
+        say "Available Definitions (#{definitions.size}):", :white
+        definitions.each do |metadata|
+          priority_icon = priority_icon(metadata.priority)
+          say "  #{priority_icon} #{metadata.version} (#{metadata.source_type})", :white
+          say "    Path: #{metadata.path}", :dim
+          say "    Mtime: #{metadata.mtime}", :dim
+          say "    Priority: #{metadata.priority}", :dim
+          say '', :clear
+        end
+
+        # Determine which definition would be used
+        if version_constraint
+          # Resolve with version constraint
+          available_versions = definitions.map(&:version)
+          selected_version = Ukiryu::Definition::VersionResolver.resolve(
+            version_constraint,
+            available_versions
+          )
+
+          if selected_version
+            selected_metadata = definitions.find { |d| d.version == selected_version }
+            say "Selected Definition (constraint: #{version_constraint}):", :cyan
+            say "  ✓ #{selected_metadata.name}/#{selected_metadata.version}", :green
+            say "    Source: #{selected_metadata.source_type}", :white
+            say "    Path: #{selected_metadata.path}", :white
+          else
+            say "✗ No version satisfies constraint: #{version_constraint}", :red
+            say '', :clear
+            say 'Available versions:', :white
+            available_versions.each do |v|
+              say "  - #{v}", :dim
+            end
+            exit 1
+          end
+        else
+          # Use highest priority definition
+          selected_metadata = definitions.first
+
+          say 'Selected Definition (highest priority):', :cyan
+          say "  ✓ #{selected_metadata.name}/#{selected_metadata.version}", :green
+          say "    Source: #{selected_metadata.source_type}", :white
+          say "    Path: #{selected_metadata.path}", :white
+          say "    Priority: #{selected_metadata.priority}", :white
+        end
+
+        # Check if definition exists and is valid
+        return unless selected_metadata && !selected_metadata.exists?
+
+        say '', :clear
+        say '⚠ Warning: Definition file does not exist!', :yellow
+      end
+
+      # Get priority icon
+      #
+      # @param priority [Integer] the priority value
+      # @return [String] icon character
+      def priority_icon(priority)
+        case priority
+        when 1 then '★'  # User
+        when 2 then '◆'  # Bundled
+        when 3 then '■'  # Local system
+        when 4 then '□'  # System
+        when 5 then '△'  # Register
+        else '·'
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/run_command.rb

@@ -22,7 +22,7 @@ module Ukiryu
       # @param command_name [String, nil] the command name (optional, uses default if nil)
       # @param params [Array<String>] key=value parameter pairs
       def run(tool_name, command_name = nil, *params)
-        setup_registry
+        setup_register
 
         # Handle the case where command_name is omitted and first param is a key=value pair
         # When user types: ukiryu exec-inline ping host=127.0.0.1
@@ -80,7 +80,7 @@ module Ukiryu
             debug: config.debug,
             dry_run: config.dry_run,
             output: config.output,
-            registry: config.registry,
+            register: config.register,
             stdin: !arguments[:stdin].nil?
           }
           logger.debug_section_ukiryu_options(ukiryu_options)
@@ -119,13 +119,19 @@ module Ukiryu
       # @param tool_name [String] the tool name
       # @return [String] the resolved command name
       def resolve_default_command(tool_name)
-        # Use Registry to load tool metadata without full resolution
-        # This avoids triggering debug output for "Tool Resolution" twice
-        require_relative '../registry'
-        require_relative '../models/tool_metadata'
+        # If --definition is provided, load from definition file
+        if options[:definition]
+          tool = Tool.load(options[:definition], validation: :strict)
+          metadata = tool.profile
+        else
+          # Use Register to load tool metadata without full resolution
+          # This avoids triggering debug output for "Tool Resolution" twice
+          require_relative '../register'
+          require_relative '../models/tool_metadata'
 
-        metadata = Registry.load_tool_metadata(tool_name.to_sym, registry_path: config.registry)
-        error! "Tool not found: #{tool_name}" unless metadata
+          metadata = Register.load_tool_metadata(tool_name.to_sym, register_path: config.register)
+          error! "Tool not found: #{tool_name}" unless metadata
+        end
 
         # Get the default command (checks YAML default_command, then implements, then tool name)
         command = metadata.default_command
@@ -194,8 +200,20 @@ module Ukiryu
           # Stage: Tool Resolution
           execution_report.tool_resolution.start! if collect_metrics
 
-          # Get tool - try find_by first for interface-based discovery, fallback to get
-          tool = Tool.find_by(tool_name.to_sym) || Tool.get(tool_name.to_sym)
+          # Load tool from definition file if --definition option provided
+          if options[:definition]
+            tool = Tool.load(options[:definition], validation: :strict)
+            # Verify that the tool name matches (if user specified one)
+            if tool_name && tool.name.to_sym != tool_name.to_sym
+              return Models::ErrorResponse.from_message(
+                "Tool name mismatch: definition file contains '#{tool.name}' but command specified '#{tool_name}'"
+              )
+            end
+          else
+            # Get tool - try find_by first for interface-based discovery, fallback to get
+            tool = Tool.find_by(tool_name.to_sym) || Tool.get(tool_name.to_sym)
+          end
+
           return Models::ErrorResponse.from_message("Tool not available: #{tool_name}") unless tool
 
           return Models::ErrorResponse.from_message("Tool found but not executable: #{tool_name}") unless tool.available?
@@ -324,11 +342,17 @@ module Ukiryu
       # @param tool_name [String] the tool name
       # @param params [Array<String>] additional parameters
       def show_tool_help(tool_name, _params = [])
-        setup_registry
+        setup_register
+
+        # Load tool from definition file if --definition option provided
+        tool = if options[:definition]
+                 Tool.load(options[:definition], validation: :strict)
+               else
+                 # Use find_by for interface-based discovery
+                 Tool.find_by(tool_name.to_sym)
+               end
 
-        # Use find_by for interface-based discovery
-        tool = Tool.find_by(tool_name.to_sym)
-        error! "Tool not found: #{tool_name}\nAvailable tools: #{Registry.tools.sort.join(', ')}" unless tool
+        error! "Tool not found: #{tool_name}\nAvailable tools: #{Register.tools.sort.join(', ')}" unless tool
 
         say '', :clear
         say "Tool: #{tool.name}", :cyan

data/lib/ukiryu/cli_commands/run_file_command.rb

@@ -20,7 +20,7 @@ module Ukiryu
       #
       # @param request_file [String] path to the request YAML file
       def run(request_file)
-        setup_registry
+        setup_register
 
         # Output debug: Ukiryu CLI Options
         if config.debug
@@ -30,7 +30,7 @@ module Ukiryu
             debug: config.debug,
             dry_run: config.dry_run,
             output: config.output,
-            registry: config.registry,
+            register: config.register,
             request_file: request_file
           }
           logger.debug_section_ukiryu_options(ukiryu_options)