ukiryu 0.1.1 → 0.1.3

data/lib/ukiryu/cli_commands/definitions_command.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative '../definition'
+
+module Ukiryu
+  module CliCommands
+    # CLI commands for managing tool definitions
+    #
+    # This command group provides functionality for:
+    # - Listing discovered definitions
+    # - Showing definition search paths
+    # - Adding definitions to the user library
+    # - Removing definitions from the user library
+    # - Showing details about specific definitions
+    class DefinitionsCommand < Thor
+      default_command :list
+
+      # List all discovered definitions
+      #
+      # @param verbose [Boolean] show detailed information
+      desc 'list', 'List all discovered definitions'
+      method_option :verbose, aliases: :v, desc: 'Show detailed information', type: :boolean, default: false
+      def list
+        definitions = Definition::Discovery.discover
+
+        if definitions.empty?
+          puts 'No definitions found.'
+          puts
+          puts 'Search paths:'
+          Definition::Discovery.search_paths.each do |path|
+            puts "  - #{path}"
+          end
+          return
+        end
+
+        if options[:verbose]
+          # Verbose output with details
+          definitions.each do |tool_name, defs|
+            puts "#{tool_name}:"
+            defs.each do |metadata|
+              priority_indicator = defs.index(metadata).zero? ? '*' : ' '
+              puts "  #{priority_indicator} #{metadata.version} (#{metadata.source_type})"
+              puts "    Path: #{metadata.path}"
+            end
+            puts
+          end
+        else
+          # Simple output
+          definitions.each do |tool_name, defs|
+            best = defs.first
+            versions_str = defs.map(&:version).join(', ')
+            puts "#{tool_name}: #{versions_str} [#{best.source_type}]"
+          end
+        end
+
+        puts "\nLegend: * = highest priority (will be used by default)"
+      end
+
+      # Show definition search paths
+      #
+      desc 'path', 'Show definition search paths'
+      def path
+        puts 'Definition search paths (in priority order):'
+        puts
+
+        paths = Definition::Discovery.search_paths
+        paths.each_with_index do |path, index|
+          prefix = index.zero? ? '(1) [Highest Priority]' : "(#{index + 1})"
+          exists = File.directory?(path) ? '✓' : '✗'
+          puts "#{prefix} #{exists} #{path}"
+        end
+
+        puts
+        puts "User directory: #{Definition::Discovery.user_definitions_directory}"
+        puts "XDG_DATA_HOME: #{Definition::Discovery.xdg_data_home}"
+        puts "XDG_DATA_DIRS: #{Definition::Discovery.xdg_data_dirs.join(':')}"
+      end
+
+      # Add a definition to the user library
+      #
+      # @param source_path [String] path to the definition file to add
+      desc 'add SOURCE', 'Add definition to user library'
+      method_option :name, aliases: :n, desc: 'Tool name (auto-detected from file if not specified)', type: :string
+      method_option :version, aliases: :V, desc: 'Version (auto-detected from file if not specified)', type: :string
+      def add(source_path)
+        source_path = File.expand_path(source_path)
+
+        unless File.exist?(source_path)
+          warn "Error: Source file not found: #{source_path}"
+          exit 1
+        end
+
+        # Load the definition to get metadata
+        begin
+          metadata = Definition::Loader.load_from_file(source_path, validation: :strict)
+        rescue DefinitionLoadError, DefinitionValidationError => e
+          warn "Error: Failed to load definition: #{e.message}"
+          exit 1
+        end
+
+        tool_name = options[:name] || metadata.name
+        version = options[:version] || metadata.version || '1.0'
+
+        # Determine target directory
+        user_dir = Definition::Discovery.user_definitions_directory
+        tool_dir = File.join(user_dir, tool_name)
+
+        # Create directories if needed
+        FileUtils.mkdir_p(tool_dir)
+
+        # Target file path
+        target_path = File.join(tool_dir, "#{version}.yaml")
+
+        # Check if target already exists
+        if File.exist?(target_path)
+          warn "Error: Definition already exists: #{target_path}"
+          warn 'Use --name and --version to specify a different tool/version.'
+          exit 1
+        end
+
+        # Copy the definition
+        FileUtils.cp(source_path, target_path)
+
+        puts 'Definition added successfully:'
+        puts "  Tool: #{tool_name}"
+        puts "  Version: #{version}"
+        puts "  Location: #{target_path}"
+      end
+
+      # Remove a definition from the user library
+      #
+      # @param tool_name [String] the tool name
+      desc 'remove TOOL', 'Remove definition from user library'
+      method_option :version, aliases: :v, desc: 'Specific version to remove (removes all if not specified)',
+                              type: :string
+      method_option :force, aliases: :f, desc: 'Skip confirmation prompt', type: :boolean, default: false
+      def remove(tool_name)
+        user_dir = Definition::Discovery.user_definitions_directory
+        tool_dir = File.join(user_dir, tool_name)
+
+        unless File.directory?(tool_dir)
+          warn "Error: No definitions found for tool '#{tool_name}'"
+          warn "User definitions directory: #{user_dir}"
+          exit 1
+        end
+
+        # Find versions to remove
+        versions = if options[:version]
+                     specific_file = File.join(tool_dir, "#{options[:version]}.yaml")
+                     if File.exist?(specific_file)
+                       [options[:version]]
+                     else
+                       warn "Error: Version #{options[:version]} not found for tool '#{tool_name}'"
+                       exit 1
+                     end
+                   else
+                     # Get all versions
+                     Dir.glob(File.join(tool_dir, '*.yaml')).map do |file|
+                       File.basename(file, '.yaml')
+                     end
+                   end
+
+        # Confirm removal
+        unless options[:force]
+          puts 'This will remove the following definitions:'
+          versions.each do |v|
+            puts "  - #{tool_name}/#{v}"
+          end
+          print 'Are you sure? [y/N] '
+          response = $stdin.gets.chomp
+          unless response.downcase == 'y'
+            puts 'Cancelled.'
+            return
+          end
+        end
+
+        # Remove files
+        versions.each do |v|
+          file_path = File.join(tool_dir, "#{v}.yaml")
+          FileUtils.rm(file_path)
+          puts "Removed: #{tool_name}/#{v}"
+        end
+
+        # Remove tool directory if empty
+        if Dir.empty?(tool_dir)
+          FileUtils.rmdir(tool_dir)
+          puts "Removed empty directory: #{tool_dir}"
+        end
+
+        puts 'Done.'
+      end
+
+      # Show details about a specific definition
+      #
+      # @param tool_name [String] the tool name
+      desc 'info TOOL', 'Show definition details'
+      method_option :version, aliases: :v, desc: 'Specific version to show (shows best available if not specified)',
+                              type: :string
+      def info(tool_name)
+        definitions = Definition::Discovery.definitions_for(tool_name)
+
+        if definitions.nil? || definitions.empty?
+          warn "Error: No definitions found for tool '#{tool_name}'"
+          exit 1
+        end
+
+        # Find the requested version or best available
+        metadata = if options[:version]
+                     definitions.find { |d| d.version == options[:version] }
+                   else
+                     definitions.first
+                   end
+
+        unless metadata
+          warn "Error: Version '#{options[:version]}' not found for tool '#{tool_name}'"
+          warn "Available versions: #{definitions.map(&:version).join(', ')}"
+          exit 1
+        end
+
+        # Show details
+        puts "Tool: #{metadata.name}"
+        puts "Version: #{metadata.version}"
+        puts "Source: #{metadata.source_type}"
+        puts "Path: #{metadata.path}"
+        puts "Exists: #{metadata.exists? ? 'Yes' : 'No'}"
+        puts "Modified: #{metadata.mtime}" if metadata.exists?
+
+        # Show all available versions
+        if definitions.length > 1
+          puts
+          puts 'Available versions:'
+          definitions.each do |defn|
+            current = defn.version == metadata.version
+            indicator = current ? '*' : ' '
+            priority_note = defn == definitions.first ? ' [default]' : ''
+            puts "  #{indicator} #{defn.version} (#{defn.source_type})#{priority_note}"
+          end
+        end
+
+        # Try to load and validate the definition
+        puts
+        begin
+          tool_def = metadata.load_definition
+          puts 'Validation: ✓ Valid'
+          puts "Display Name: #{tool_def.display_name}" if tool_def.display_name
+          puts "Homepage: #{tool_def.homepage}" if tool_def.homepage
+        rescue DefinitionLoadError, DefinitionValidationError => e
+          puts 'Validation: ✗ Invalid'
+          puts "Error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/cli_commands/describe_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
@@ -78,6 +78,9 @@ module Ukiryu
 
           # Show usage if available
           say "    Usage: #{cmd.usage}", :dim if cmd.usage
+
+          # Show env var sets if available
+          say "    Env Var Sets: #{cmd.use_env_vars.join(', ')}", :dim if cmd.use_env_vars && !cmd.use_env_vars.empty?
         end
 
         say '', :clear
@@ -123,6 +126,9 @@ module Ukiryu
           cmd_display = (cmd.name || 'unnamed').to_s.ljust(20)
           desc_display = cmd.description || 'No description'
           say "  #{cmd_display} #{desc_display}", :white
+
+          # Show env var sets if available
+          say "    Env Var Sets: #{cmd.use_env_vars.join(', ')}", :dim if cmd.use_env_vars && !cmd.use_env_vars.empty?
         end
 
         say '', :clear
@@ -154,9 +160,9 @@ module Ukiryu
           say '', :clear
         end
 
-        # Execution mode
-        if cmd.execution_mode
-          say "Execution Mode: #{cmd.execution_mode}", :white
+        # Env var sets
+        if cmd.use_env_vars && !cmd.use_env_vars.empty?
+          say "Env Var Sets: #{cmd.use_env_vars.join(', ')}", :white
           say '', :clear
         end
 
@@ -200,13 +206,13 @@ module Ukiryu
             name = opt.name || 'unnamed'
             cli = opt.cli || 'N/A'
             type = opt.type || 'string'
-            format = opt.format || 'N/A'
+            assignment_delimiter = opt.assignment_delimiter || 'auto'
             default = opt.default
             platforms = opt.platforms || []
 
             say "  #{name} (#{type})", :white
             say "    CLI: #{cli}", :dim
-            say "    Format: #{format}", :dim if format != 'N/A'
+            say "    Assignment Delimiter: #{assignment_delimiter}", :dim if assignment_delimiter != 'auto'
             say "    Default: #{default}", :dim if default
             say "    Platforms: #{platforms.join(', ')}", :dim if platforms.any?
             say "    Description: #{opt.description}", :dim if opt.description

data/lib/ukiryu/cli_commands/describe_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/docs_command.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../definition/documentation_generator'
+
+module Ukiryu
+  module CliCommands
+    # Generate documentation from tool definitions
+    #
+    # The docs command generates human-readable documentation
+    # from tool definitions in various formats.
+    class DocsCommand < Thor
+      class_option :verbose, type: :boolean, default: false
+      class_option :format, type: :string, default: 'markdown', enum: %w[markdown md asciidoc adoc]
+      class_option :output, type: :string, desc: 'Output file path'
+
+      desc 'generate TOOL', 'Generate documentation for a tool'
+      option :register, type: :string, desc: 'Register path'
+      def generate(tool_name)
+        generate_docs(tool_name)
+      end
+
+      desc 'generate-all', 'Generate documentation for all tools'
+      option :register, type: :string, desc: 'Register path'
+      option :output_dir, type: :string, desc: 'Output directory', default: 'docs'
+      def generate_all
+        generate_all_docs
+      end
+
+      desc 'serve', 'Serve documentation locally (experimental)'
+      option :port, type: :numeric, default: 8000
+      def serve
+        serve_docs
+      end
+
+      private
+
+      # Generate documentation for a tool
+      #
+      # @param tool_name [String] the tool name
+      def generate_docs(tool_name)
+        register_path = options[:register] || Ukiryu::Register.default_register_path
+        tool_path = File.join(register_path, 'tools', tool_name)
+
+        say_error("Tool not found: #{tool_name}") unless Dir.exist?(tool_path)
+
+        # Find latest version
+        version_dirs = Dir.entries(tool_path)
+                          .reject { |e| e.start_with?('.') }
+                          .select { |e| File.directory?(File.join(tool_path, e)) }
+                          .sort { |a, b| Gem::Version.new(b) <=> Gem::Version.new(a) }
+
+        say_error("No versions found for tool: #{tool_name}") if version_dirs.empty?
+
+        latest_version = version_dirs.first
+        definition_file = Dir.glob(File.join(tool_path, latest_version, '*.yaml')).first
+
+        say_error("No definition file found for #{tool_name} #{latest_version}") unless definition_file
+
+        definition = Ukiryu::Definition::Loader.load_from_file(definition_file)
+        format = normalize_format
+
+        begin
+          docs = Ukiryu::Definition::DocumentationGenerator.generate(definition, format: format)
+        rescue ArgumentError => e
+          say_error("Error: #{e.message}")
+        end
+
+        # Output
+        if options[:output]
+          File.write(options[:output], docs)
+          say "✓ Documentation written to: #{options[:output]}", :green
+        else
+          say docs, :white
+        end
+      end
+
+      # Generate documentation for all tools
+      def generate_all_docs
+        register_path = options[:register] || Ukiryu::Register.default_register_path
+        tools_dir = File.join(register_path, 'tools')
+
+        say_error("Tools directory not found: #{tools_dir}") unless Dir.exist?(tools_dir)
+
+        output_dir = options[:output_dir]
+        FileUtils.mkdir_p(output_dir)
+
+        count = 0
+        Dir.glob(File.join(tools_dir, '*', '*/*.yaml')).each do |file|
+          parts = file.split('/')
+          tool_name = parts[-3]
+          version = parts[-2]
+          File.basename(file, '.yaml')
+
+          definition = Ukiryu::Definition::Loader.load_from_file(file)
+          format = normalize_format
+
+          begin
+            docs = Ukiryu::Definition::DocumentationGenerator.generate(definition, format: format)
+          rescue ArgumentError => e
+            say "Warning: Could not generate docs for #{file}: #{e.message}", :yellow
+            next
+          end
+
+          # Write to file
+          output_file = File.join(output_dir, "#{tool_name}-#{version}.#{format == :asciidoc ? 'adoc' : 'md'}")
+          File.write(output_file, docs)
+          count += 1
+
+          say "✓ Generated: #{output_file}", :green
+        end
+
+        say '', :clear
+        say "Generated #{count} documentation file(s) in: #{output_dir}", :cyan
+      end
+
+      # Serve documentation locally
+      def serve_docs
+        say 'Documentation server is not yet implemented.', :yellow
+        say "\nFor now, you can use a simple HTTP server:", :white
+        say "  python3 -m http.server #{options[:port]}", :dim
+        say "  ruby -run -e httpd . -p #{options[:port]}", :dim
+      end
+
+      # Normalize format option
+      #
+      # @return [Symbol] normalized format
+      def normalize_format
+        case options[:format]
+        when 'adoc'
+          :asciidoc
+        when 'md'
+          :markdown
+        else
+          options[:format].to_sym
+        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/exec_inline_command.rb.fixed

@@ -18,7 +18,7 @@ module Ukiryu
         # @param command_name [String] the command name
         # @param params [Array<String>] key=value parameter pairs
       def run(tool_name, command_name, *params)
-          setup_registry
+          setup_register
 
           # Parse key=value pairs into arguments hash
           arguments = parse_inline_params(params)

data/lib/ukiryu/cli_commands/extract_command.rb

@@ -68,8 +68,8 @@ module Ukiryu
         if options[:method] && options[:method] != 'auto'
           say "  - #{options[:method]} (explicitly selected)", :white
         else
-          say "  - native (try --ukiryu-definition flag)", :white
-          say "  - help (parse --help output)", :white
+          say '  - native (try --ukiryu-definition flag)', :white
+          say '  - help (parse --help output)', :white
         end
 
         say '', :clear

data/lib/ukiryu/cli_commands/info_command.rb

@@ -11,11 +11,11 @@ module Ukiryu
       #
       # @param tool_name [String] the tool name
       def run(tool_name)
-        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
 
         profile = tool.profile
         show_all = options[:all]
@@ -122,22 +122,22 @@ module Ukiryu
       # @param current_tool_name [String] the current tool name to exclude
       # @return [Array<String>] list of other tool names
       def find_other_implementations(interface_name, current_tool_name)
-        require_relative '../registry'
+        require_relative '../register'
 
         implementations = []
         interface_sym = interface_name.to_sym
 
         if config.debug
           say "  [DEBUG] Looking for tools implementing '#{interface_name}' (excluding '#{current_tool_name}')", :dim
-          say "  [DEBUG] Registry tools: #{Registry.tools.inspect}", :dim
+          say "  [DEBUG] Register tools: #{Register.tools.inspect}", :dim
         end
 
-        Registry.tools.each do |tool_name|
+        Register.tools.each do |tool_name|
           next if tool_name == current_tool_name
 
           begin
-            # Don't pass registry_path - let it use the default
-            tool_metadata = Registry.load_tool_metadata(tool_name.to_sym)
+            # Don't pass register_path - let it use the default
+            tool_metadata = Register.load_tool_metadata(tool_name.to_sym)
             if config.debug
               say "  [DEBUG] #{tool_name} -> metadata: #{tool_metadata ? tool_metadata.implements : 'nil'}", :dim
             end