rufio 0.41.0 → 0.60.0

data/lib/rufio/command_mode.rb

@@ -3,21 +3,58 @@
 require 'open3'
 
 module Rufio
-  # コマンドモード - プラグインコマンドを実行するためのインターフェース
+  # コマンドモード - DSLコマンドを実行するための統一インターフェース
+  # すべてのコマンドはDslCommandとして扱われる
   class CommandMode
     attr_accessor :background_executor
+    attr_reader :script_runner, :script_path_manager
 
     def initialize(background_executor = nil)
       @commands = {}
       @background_executor = background_executor
-      load_plugin_commands
+      @script_runner = nil
+      @script_path_manager = nil
+      @job_manager = nil
+      load_builtin_commands
+      load_dsl_commands
+    end
+
+    # ScriptRunnerを設定する
+    # @param script_paths [Array<String>] スクリプトパス
+    # @param job_manager [JobManager] ジョブマネージャー
+    def setup_script_runner(script_paths:, job_manager:)
+      @job_manager = job_manager
+      @script_runner = ScriptRunner.new(
+        script_paths: script_paths,
+        job_manager: job_manager
+      )
+    end
+
+    # ScriptPathManagerを設定する（設定ファイルベース）
+    # @param config_file [String] 設定ファイルのパス
+    # @param job_manager [JobManager] ジョブマネージャー
+    def setup_script_path_manager(config_file:, job_manager:)
+      @job_manager = job_manager
+      @script_path_manager = ScriptPathManager.new(config_file)
+      # ScriptRunnerも設定（ScriptPathManagerのパスを使用）
+      @script_runner = ScriptRunner.new(
+        script_paths: @script_path_manager.paths,
+        job_manager: job_manager
+      )
     end
 
     # コマンドを実行する
-    def execute(command_string)
+    # @param command_string [String] コマンド文字列
+    # @param working_dir [String, nil] 作業ディレクトリ（スクリプト実行時に使用）
+    def execute(command_string, working_dir: nil)
       # 空のコマンドは無視
       return nil if command_string.nil? || command_string.strip.empty?
 
+      # スクリプト実行 (@ で始まる場合)
+      if command_string.strip.start_with?('@')
+        return execute_script(command_string.strip[1..-1], working_dir)
+      end
+
       # シェルコマンドの実行 (! で始まる場合)
       if command_string.strip.start_with?('!')
         shell_command = command_string.strip[1..-1]
@@ -38,32 +75,20 @@ module Rufio
       # コマンド名を取得 (前後の空白を削除)
       command_name = command_string.strip.to_sym
 
-      # コマンドが存在するかチェック
-      unless @commands.key?(command_name)
-        return "⚠️  コマンドが見つかりません: #{command_name}"
+      # 統一されたコマンドストアから検索
+      command = @commands[command_name]
+      if command
+        # 内部コマンドを実行
+        return execute_unified_command(command_name, command)
       end
 
-      # バックグラウンドエグゼキュータが利用可能な場合は非同期実行
-      if @background_executor
-        command_method = @commands[command_name][:method]
-        command_display_name = command_name.to_s
-
-        if @background_executor.execute_ruby_async(command_display_name) do
-             command_method.call
-           end
-          return "🔄 バックグラウンドで実行中: #{command_display_name}"
-        else
-          return "⚠️  既にコマンドが実行中です"
-        end
+      # 内部コマンドが見つからない場合、スクリプトパスから検索
+      if @script_path_manager || @script_runner
+        script_result = try_execute_script_from_paths(command_string.strip, working_dir)
+        return script_result if script_result
       end
 
-      # バックグラウンドエグゼキュータがない場合は同期実行
-      begin
-        command_method = @commands[command_name][:method]
-        command_method.call
-      rescue StandardError => e
-        "⚠️  コマンド実行エラー: #{e.message}"
-      end
+      "⚠️  コマンドが見つかりません: #{command_name}"
     end
 
     # 利用可能なコマンドのリストを取得
@@ -73,17 +98,83 @@ 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
+
+    # スクリプト名を補完する
+    # @param prefix [String] 入力中の文字列（@を含む）
+    # @return [Array<String>] 補完候補（@付き）
+    def complete_script(prefix)
+      return [] unless @script_runner
+
+      # @を除去して検索
+      search_prefix = prefix.sub(/^@/, '')
+      @script_runner.complete(search_prefix).map { |name| "@#{name}" }
+    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)
       # コマンドが空の場合
@@ -112,24 +203,44 @@ module Rufio
       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
+    # スクリプトを実行する（@プレフィックス用）
+    # @param script_name [String] スクリプト名
+    # @param working_dir [String, nil] 作業ディレクトリ
+    # @return [String] 実行結果メッセージ
+    def execute_script(script_name, working_dir)
+      unless @script_runner
+        return "⚠️  スクリプトランナーが設定されていません"
+      end
+
+      working_dir ||= Dir.pwd
+
+      job = @script_runner.run(script_name, working_dir: working_dir)
+
+      if job
+        "🚀 ジョブを開始: #{script_name}"
+      else
+        "⚠️  スクリプトが見つかりません: #{script_name}"
+      end
+    end
+
+    # スクリプトパスからスクリプトを検索して実行を試みる
+    # @param command_name [String] コマンド名
+    # @param working_dir [String, nil] 作業ディレクトリ
+    # @return [String, nil] 実行結果メッセージ、見つからない場合nil
+    def try_execute_script_from_paths(command_name, working_dir)
+      return nil unless @script_runner
+
+      script = @script_runner.find_script(command_name)
+      return nil unless script
+
+      working_dir ||= Dir.pwd
+
+      job = @script_runner.run(command_name, working_dir: working_dir)
+
+      if job
+        "🚀 ジョブを開始: #{script[:name]}"
+      else
+        nil
       end
     end
   end

data/lib/rufio/config_loader.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require_relative 'config'
 
 module Rufio
   class ConfigLoader
     CONFIG_PATH = File.expand_path('~/.config/rufio/config.rb').freeze
+    YAML_CONFIG_PATH = File.expand_path('~/.config/rufio/config.yml').freeze
 
     class << self
       def load_config
@@ -60,6 +62,41 @@ module Rufio
         load_config[:command_history_size] || 1000
       end
 
+      # スクリプトパスの配列を取得
+      # @return [Array<String>] 展開済みのスクリプトパス
+      def script_paths
+        yaml_config = load_yaml_config
+        paths = yaml_config[:script_paths] || default_script_paths
+        expand_script_paths(paths)
+      end
+
+      # デフォルトのスクリプトパス
+      # @return [Array<String>] デフォルトパス
+      def default_script_paths
+        [File.expand_path('~/.config/rufio/scripts')]
+      end
+
+      # スクリプトパスを展開
+      # @param paths [Array<String>] パスの配列
+      # @return [Array<String>] 展開済みのパス
+      def expand_script_paths(paths)
+        paths.map { |p| File.expand_path(p) }
+      end
+
+      # YAML設定ファイルを読み込む
+      # @param path [String, nil] 設定ファイルのパス（nilの場合はデフォルト）
+      # @return [Hash] 設定内容
+      def load_yaml_config(path = nil)
+        config_path = path || YAML_CONFIG_PATH
+        return {} unless File.exist?(config_path)
+
+        yaml = YAML.safe_load(File.read(config_path), symbolize_names: true)
+        yaml || {}
+      rescue StandardError => e
+        warn "Failed to load YAML config: #{e.message}"
+        {}
+      end
+
       private
 
       def load_config_file

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/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