rufio 0.40.1 → 0.50.0

data/lib/rufio/background_command_executor.rb

@@ -3,7 +3,7 @@
 require 'open3'
 
 module Rufio
-  # バックグラウンドでシェルコマンドを実行するクラス
+  # バックグラウンドでシェルコマンドまたはRubyコードを実行するクラス
   class BackgroundCommandExecutor
     attr_reader :command_logger
 
@@ -13,11 +13,12 @@ module Rufio
       @command_logger = command_logger
       @thread = nil
       @command = nil
+      @command_type = nil  # :shell または :ruby
       @completed = false
       @completion_message = nil
     end
 
-    # コマンドを非同期で実行
+    # シェルコマンドを非同期で実行
     # @param command [String] 実行するコマンド
     # @return [Boolean] 実行を開始した場合はtrue、既に実行中の場合はfalse
     def execute_async(command)
@@ -25,6 +26,7 @@ module Rufio
       return false if running?
 
       @command = command
+      @command_type = :shell
       @completed = false
       @completion_message = nil
 
@@ -73,6 +75,54 @@ module Rufio
       true
     end
 
+    # Rubyコード（プラグインコマンド）を非同期で実行
+    # @param command_name [String] コマンド名（表示用）
+    # @param block [Proc] 実行するコードブロック
+    # @return [Boolean] 実行を開始した場合はtrue、既に実行中の場合はfalse
+    def execute_ruby_async(command_name, &block)
+      # 既に実行中の場合は新しいコマンドを開始しない
+      return false if running?
+
+      @command = command_name
+      @command_type = :ruby
+      @completed = false
+      @completion_message = nil
+
+      @thread = Thread.new do
+        begin
+          # Rubyコードを実行
+          result = block.call
+
+          # 結果をログに保存
+          output = result.to_s
+
+          @command_logger.log(
+            command_name,
+            output,
+            success: true,
+            error: nil
+          )
+
+          # 完了メッセージを生成
+          @completion_message = "✓ #{command_name} 完了"
+          @completed = true
+        rescue StandardError => e
+          # エラーが発生した場合もログに記録
+          @command_logger.log(
+            command_name,
+            "",
+            success: false,
+            error: e.message
+          )
+
+          @completion_message = "✗ #{command_name} エラー: #{e.message}"
+          @completed = true
+        end
+      end
+
+      true
+    end
+
     # コマンドが実行中かどうか
     # @return [Boolean] 実行中の場合はtrue
     def running?
@@ -85,6 +135,18 @@ module Rufio
       @completion_message
     end
 
+    # 現在実行中のコマンド名を取得
+    # @return [String, nil] コマンド名（実行中でない場合はnil）
+    def current_command
+      running? ? @command : nil
+    end
+
+    # コマンドタイプを取得
+    # @return [Symbol, nil] :shell または :ruby（実行中でない場合はnil）
+    def command_type
+      running? ? @command_type : nil
+    end
+
     private
 
     # コマンド文字列からコマンド名を抽出

data/lib/rufio/builtin_commands.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rufio
+  # 組み込みコマンドを定義するモジュール
+  # DSL形式で定義されたコマンドをDslCommandインスタンスとして提供する
+  module BuiltinCommands
+    class << self
+      # 組み込みコマンドをロードする
+      # @return [Hash{Symbol => DslCommand}] コマンド名をキーとしたハッシュ
+      def load
+        commands = {}
+
+        # hello コマンド
+        commands[:hello] = DslCommand.new(
+          name: "hello",
+          ruby_block: -> { "Hello, World!\n\nこのコマンドはDSLで定義されています。" },
+          description: "挨拶メッセージを返す"
+        )
+
+        # stop コマンド
+        commands[:stop] = DslCommand.new(
+          name: "stop",
+          ruby_block: lambda {
+            sleep 5
+            "done"
+          },
+          description: "5秒待機してdoneを返す"
+        )
+
+        commands
+      end
+    end
+  end
+end

data/lib/rufio/command_mode.rb

@@ -3,14 +3,16 @@
 require 'open3'
 
 module Rufio
-  # コマンドモード - プラグインコマンドを実行するためのインターフェース
+  # コマンドモード - DSLコマンドを実行するための統一インターフェース
+  # すべてのコマンドはDslCommandとして扱われる
   class CommandMode
     attr_accessor :background_executor
 
     def initialize(background_executor = nil)
       @commands = {}
       @background_executor = background_executor
-      load_plugin_commands
+      load_builtin_commands
+      load_dsl_commands
     end
 
     # コマンドを実行する
@@ -38,18 +40,14 @@ module Rufio
       # コマンド名を取得 (前後の空白を削除)
       command_name = command_string.strip.to_sym
 
-      # コマンドが存在するかチェック
-      unless @commands.key?(command_name)
+      # 統一されたコマンドストアから検索
+      command = @commands[command_name]
+      unless command
         return "⚠️  コマンドが見つかりません: #{command_name}"
       end
 
-      # コマンドを実行
-      begin
-        command_method = @commands[command_name][:method]
-        command_method.call
-      rescue StandardError => e
-        "⚠️  コマンド実行エラー: #{e.message}"
-      end
+      # 統一された実行パス
+      execute_unified_command(command_name, command)
     end
 
     # 利用可能なコマンドのリストを取得
@@ -59,17 +57,72 @@ module Rufio
 
     # コマンドの情報を取得
     def command_info(command_name)
-      return nil unless @commands.key?(command_name)
+      command = @commands[command_name]
+      return nil unless command
 
       {
         name: command_name,
-        plugin: @commands[command_name][:plugin],
-        description: @commands[command_name][:description]
+        plugin: command[:source] || "dsl",
+        description: command[:command].description
       }
     end
 
+    # DSLコマンドをロードする
+    # @param paths [Array<String>, nil] 設定ファイルのパス配列（nilの場合はデフォルトパス）
+    def load_dsl_commands(paths = nil)
+      loader = DslCommandLoader.new
+
+      commands = if paths
+                   loader.load_from_paths(paths)
+                 else
+                   loader.load
+                 end
+
+      # ユーザーDSLコマンドは既存のコマンドを上書きする（優先度が高い）
+      commands.each do |cmd|
+        @commands[cmd.name.to_sym] = {
+          command: cmd,
+          source: "dsl"
+        }
+      end
+    end
+
     private
 
+    # 組み込みコマンドをロードする
+    def load_builtin_commands
+      builtin = BuiltinCommands.load
+      builtin.each do |name, cmd|
+        @commands[name] = {
+          command: cmd,
+          source: "builtin"
+        }
+      end
+    end
+
+    # 統一されたコマンド実行
+    # @param command_name [Symbol] コマンド名
+    # @param command [Hash] コマンド情報 { command: DslCommand, source: String }
+    # @return [Hash] 実行結果
+    def execute_unified_command(command_name, command)
+      dsl_cmd = command[:command]
+
+      # バックグラウンドエグゼキュータが利用可能な場合は非同期実行
+      if @background_executor
+        command_display_name = command_name.to_s
+        if @background_executor.execute_ruby_async(command_display_name) do
+             ScriptExecutor.execute_command(dsl_cmd)
+           end
+          return "🔄 バックグラウンドで実行中: #{command_display_name}"
+        else
+          return "⚠️  既にコマンドが実行中です"
+        end
+      end
+
+      # 同期実行
+      ScriptExecutor.execute_command(dsl_cmd)
+    end
+
     # シェルコマンドを実行する
     def execute_shell_command(shell_command)
       # コマンドが空の場合
@@ -97,26 +150,5 @@ module Rufio
         { success: false, error: "コマンド実行エラー: #{e.message}" }
       end
     end
-
-    # プラグインからコマンドを読み込む
-    def load_plugin_commands
-      # 有効なプラグインを取得
-      enabled_plugins = PluginManager.enabled_plugins
-
-      # 各プラグインからコマンドを取得
-      enabled_plugins.each do |plugin|
-        plugin_name = plugin.name
-        plugin_commands = plugin.commands
-
-        # 各コマンドを登録
-        plugin_commands.each do |command_name, command_method|
-          @commands[command_name] = {
-            method: command_method,
-            plugin: plugin_name,
-            description: plugin.description
-          }
-        end
-      end
-    end
   end
 end

data/lib/rufio/dsl_command.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Rufio
+  # DSLで定義されたコマンドを表すクラス
+  class DslCommand
+    attr_reader :name, :script, :description, :interpreter, :errors
+    attr_reader :ruby_block, :shell_command
+
+    # コマンドを初期化する
+    # @param name [String] コマンド名
+    # @param script [String, nil] スクリプトパス
+    # @param description [String] コマンドの説明
+    # @param interpreter [String, nil] インタープリタ（nilの場合は自動検出）
+    # @param ruby_block [Proc, nil] inline Rubyブロック
+    # @param shell_command [String, nil] inline シェルコマンド
+    def initialize(name:, script: nil, description: "", interpreter: nil,
+                   ruby_block: nil, shell_command: nil)
+      @name = name.to_s
+      @script = script ? normalize_path(script.to_s) : nil
+      @description = description.to_s
+      @interpreter = interpreter || auto_resolve_interpreter
+      @ruby_block = ruby_block
+      @shell_command = shell_command
+      @errors = []
+    end
+
+    # コマンドタイプを返す
+    # @return [Symbol] :ruby, :shell, :script のいずれか
+    def command_type
+      if @ruby_block
+        :ruby
+      elsif @shell_command
+        :shell
+      else
+        :script
+      end
+    end
+
+    # コマンドが有効かどうかを検証する
+    # @return [Boolean]
+    def valid?
+      @errors = []
+      validate_name
+      validate_execution_source
+      @errors.empty?
+    end
+
+    # 実行用の引数配列を返す
+    # @return [Array<String>] [インタープリタ, スクリプトパス]
+    def to_execution_args
+      [@interpreter, @script]
+    end
+
+    # ハッシュ表現を返す
+    # @return [Hash]
+    def to_h
+      hash = {
+        name: @name,
+        script: @script,
+        description: @description,
+        interpreter: @interpreter
+      }
+      hash[:has_ruby_block] = true if @ruby_block
+      hash[:shell_command] = @shell_command if @shell_command
+      hash
+    end
+
+    private
+
+    # パスを正規化する（チルダ展開、パストラバーサル解決）
+    # @param path [String] 入力パス
+    # @return [String] 正規化されたパス
+    def normalize_path(path)
+      return "" if path.empty?
+
+      # チルダを展開
+      expanded = File.expand_path(path)
+
+      # ファイルが存在する場合は実際のパスを取得（パストラバーサル解決）
+      if File.exist?(expanded)
+        File.realpath(expanded)
+      else
+        # ファイルが存在しない場合は展開されたパスをそのまま返す
+        expanded
+      end
+    end
+
+    # 拡張子からインタープリタを自動検出する
+    # @return [String, nil]
+    def auto_resolve_interpreter
+      return nil if @script.nil? || @script.empty?
+
+      InterpreterResolver.resolve_from_path(@script)
+    end
+
+    # コマンド名のバリデーション
+    def validate_name
+      if @name.empty?
+        @errors << "Command name is required"
+      end
+    end
+
+    # 実行ソースのバリデーション
+    # ruby_block, shell_command, script のいずれかが必要
+    def validate_execution_source
+      # ruby_block または shell_command がある場合はスクリプト不要
+      return if @ruby_block || @shell_command
+
+      # スクリプトパスのバリデーション
+      if @script.nil? || @script.empty?
+        @errors << "Script path is required"
+        return
+      end
+
+      unless File.exist?(@script)
+        @errors << "Script not found: #{@script}"
+      end
+    end
+  end
+end

data/lib/rufio/dsl_command_loader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Rufio
+  # DSL設定ファイルを読み込んでDslCommandを生成するクラス
+  class DslCommandLoader
+    attr_reader :errors, :warnings
+
+    def initialize
+      @errors = []
+      @warnings = []
+    end
+
+    # 文字列からDSLを解析してコマンドをロードする
+    # @param dsl_string [String] DSL文字列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_string(dsl_string)
+      @errors = []
+      @warnings = []
+
+      context = DslContext.new
+      begin
+        context.instance_eval(dsl_string)
+      rescue SyntaxError, StandardError => e
+        @errors << "DSL parse error: #{e.message}"
+        return []
+      end
+
+      validate_commands(context.commands)
+    end
+
+    # ファイルからDSLをロードする
+    # @param file_path [String] 設定ファイルのパス
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_file(file_path)
+      @errors = []
+      @warnings = []
+
+      expanded_path = File.expand_path(file_path)
+      unless File.exist?(expanded_path)
+        return []
+      end
+
+      content = File.read(expanded_path)
+      load_from_string(content)
+    end
+
+    # 複数のパスからDSLをロードする
+    # @param paths [Array<String>] 設定ファイルのパス配列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load_from_paths(paths)
+      commands = []
+
+      paths.each do |path|
+        commands.concat(load_from_file(path))
+      end
+
+      commands
+    end
+
+    # デフォルトのパスからDSLをロードする
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def load
+      load_from_paths(default_config_paths)
+    end
+
+    # デフォルトの設定ファイルパスを返す
+    # @return [Array<String>] 設定ファイルパスの配列
+    def default_config_paths
+      home = Dir.home
+      [
+        File.join(home, ".rufio", "commands.rb"),
+        File.join(home, ".config", "rufio", "commands.rb")
+      ]
+    end
+
+    private
+
+    # コマンドをバリデーションし、有効なもののみを返す
+    # @param commands [Array<DslCommand>] コマンドの配列
+    # @return [Array<DslCommand>] 有効なコマンドの配列
+    def validate_commands(commands)
+      valid_commands = []
+
+      commands.each do |cmd|
+        if cmd.valid?
+          valid_commands << cmd
+        else
+          @warnings << "Command '#{cmd.name}' is invalid: #{cmd.errors.join(', ')}"
+        end
+      end
+
+      valid_commands
+    end
+
+    # DSL評価用の独立したコンテキスト
+    class DslContext < BasicObject
+      attr_reader :commands
+
+      def initialize
+        @commands = []
+      end
+
+      # コマンドを定義する
+      # @param name [String] コマンド名
+      # @yield コマンドの設定ブロック
+      def command(name, &block)
+        builder = CommandBuilder.new(name)
+        builder.instance_eval(&block) if block
+        @commands << builder.build
+      end
+
+      # 安全でないメソッドをブロック
+      def method_missing(method_name, *_args)
+        ::Kernel.raise ::NoMethodError, "Method '#{method_name}' is not allowed in DSL"
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        false
+      end
+    end
+
+    # コマンドビルダー
+    class CommandBuilder
+      def initialize(name)
+        @name = name
+        @script = nil
+        @description = ""
+        @interpreter = nil
+        @ruby_block = nil
+        @shell_command = nil
+      end
+
+      def script(path)
+        @script = path
+      end
+
+      def description(desc)
+        @description = desc
+      end
+
+      def interpreter(interp)
+        @interpreter = interp
+      end
+
+      # inline Rubyブロックを定義
+      def ruby(&block)
+        @ruby_block = block
+      end
+
+      # inline シェルコマンドを定義
+      def shell(command)
+        @shell_command = command
+      end
+
+      def build
+        DslCommand.new(
+          name: @name,
+          script: @script,
+          description: @description,
+          interpreter: @interpreter,
+          ruby_block: @ruby_block,
+          shell_command: @shell_command
+        )
+      end
+
+      # 未知のメソッドは無視
+      def method_missing(_method_name, *_args)
+        # DSL内で未知のメソッドが呼ばれた場合は無視
+        nil
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/rufio/file_preview.rb

@@ -67,12 +67,20 @@ module Rufio
         file.each_line.with_index do |line, index|
           break if index >= max_lines
 
-          # truncate too long lines
-          if line.length > MAX_LINE_LENGTH
-            line = line[0...MAX_LINE_LENGTH] + "..."
-          end
+          begin
+            # Ensure line is properly encoded as UTF-8
+            line = line.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+
+            # truncate too long lines
+            if line.length > MAX_LINE_LENGTH
+              line = line[0...MAX_LINE_LENGTH] + "..."
+            end
 
-          lines << line.chomp
+            lines << line.chomp
+          rescue EncodingError, ArgumentError => e
+            # If encoding fails, add placeholder
+            lines << "[encoding error in line #{index + 1}]"
+          end
         end
 
         # check if there are more lines to read
@@ -91,7 +99,15 @@ module Rufio
         File.open(file_path, "r:Shift_JIS:UTF-8", invalid: :replace, undef: :replace, replace: '�') do |file|
           file.each_line.with_index do |line, index|
             break if index >= max_lines
-            lines << line.chomp
+
+            begin
+              # Ensure line is properly encoded as UTF-8
+              line = line.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+              lines << line.chomp
+            rescue EncodingError, ArgumentError => e
+              # If encoding fails, add placeholder
+              lines << "[encoding error in line #{index + 1}]"
+            end
           end
           truncated = !file.eof?
         end

data/lib/rufio/interpreter_resolver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rufio
+  # 拡張子からインタープリタを解決するクラス
+  class InterpreterResolver
+    # デフォルトの拡張子とインタープリタのマッピング
+    DEFAULT_EXTENSIONS = {
+      ".rb" => "ruby",
+      ".py" => "python3",
+      ".sh" => "bash",
+      ".js" => "node",
+      ".pl" => "perl",
+      ".lua" => "lua",
+      ".ts" => "ts-node",
+      ".php" => "php",
+      ".ps1" => nil # プラットフォーム依存
+    }.freeze
+
+    class << self
+      # 拡張子からインタープリタを解決する
+      # @param extension [String] 拡張子（ドット付きまたはなし）
+      # @return [String, nil] インタープリタ名、解決できない場合はnil
+      def resolve(extension)
+        # ドットで始まらない場合は追加
+        ext = extension.start_with?(".") ? extension : ".#{extension}"
+        ext = ext.downcase
+
+        # PowerShellはプラットフォーム依存
+        return resolve_powershell if ext == ".ps1"
+
+        DEFAULT_EXTENSIONS[ext]
+      end
+
+      # ファイルパスから拡張子を取得してインタープリタを解決する
+      # @param path [String] ファイルパス
+      # @return [String, nil] インタープリタ名、解決できない場合はnil
+      def resolve_from_path(path)
+        ext = File.extname(path)
+        return nil if ext.empty?
+
+        resolve(ext)
+      end
+
+      # 全ての拡張子マッピングを取得する
+      # @return [Hash] 拡張子とインタープリタのマッピング
+      def all_extensions
+        # PowerShellのプラットフォーム依存を解決した状態で返す
+        DEFAULT_EXTENSIONS.merge(".ps1" => resolve_powershell)
+      end
+
+      # Windowsプラットフォームかどうか
+      # @return [Boolean]
+      def windows?
+        RUBY_PLATFORM =~ /mingw|mswin|cygwin/ ? true : false
+      end
+
+      # macOSプラットフォームかどうか
+      # @return [Boolean]
+      def macos?
+        RUBY_PLATFORM =~ /darwin/ ? true : false
+      end
+
+      # Linuxプラットフォームかどうか
+      # @return [Boolean]
+      def linux?
+        RUBY_PLATFORM =~ /linux/ ? true : false
+      end
+
+      private
+
+      # PowerShellのインタープリタを解決する
+      # WindowsではpowershellとWindowsではpwsh
+      # @return [String]
+      def resolve_powershell
+        windows? ? "powershell" : "pwsh"
+      end
+    end
+  end
+end