rufio 0.70.0 → 0.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7c56fe39c80425ba94128d7e8531584e1d7530d9eb78d323b59d34563df1fe3
-  data.tar.gz: 659fe182e9aace392e902151caac5a289b969db060f31f7176c2545e22d452c8
+  metadata.gz: a5c4fc956ed9bcb90569c8c7fcdd023fec3d31cdf1852f075ba40c9746a654dc
+  data.tar.gz: f07ae9f1f0071de307b407e5322f3f2a53c62fb654f023223f7214be79350dc3
 SHA512:
-  metadata.gz: 01fe9fe08f1e494eafcfc18aeb1a8b208c6406b60525d81a6b0ebebe3131fa8388f3b86631d7ae2ea15ec02f20eaf21d3daaa01eec6a011174050750b5f51fb4
-  data.tar.gz: 4920c3320a0df0d87b0af4b410b59722efce3163f53f5098c5ceadcb45f5124b49f4c0774d9e22daef1d293f3417a1fa397977932946a776210f4452bf141ecb
+  metadata.gz: '097aed068bd564b961c159504b7396c4d0dec7b9eb4be819d2f83380fc10aa86e698c316b9e95bfb012863790ea53cbe0ee521d3561919cdde61fbafcbb22959'
+  data.tar.gz: 6d1d2ce8640debc3fe6fbe282e75a959bb4c7a846f21cde65d0a4cd2a713329c7416591c2d182b05e7bd67b4df9895071cac32dc9ab85940459eed8f19660881

data/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.80.0] - 2026-02-21
+
+### Added
+- **Syntax Highlighting**: File preview now supports syntax highlighting via `bat`
+  - 19 languages supported: Ruby, Python, JS, TS, Go, Rust, Shell, C, C++, Java, SQL, TOML, YAML, JSON, HTML, CSS, Markdown, Dockerfile, Makefile
+  - Graceful fallback to plain text when `bat` is not installed
+  - mtime-based cache for instant re-display of previously viewed files
+  - Health check support (`rufio -c`) now reports `bat` availability
+- **New classes**: `AnsiLineParser`, `SyntaxHighlighter`
+- **New tests**: `test_ansi_line_parser.rb` (25 tests), `test_syntax_highlighter.rb` (+7 async tests)
+
+### Fixed
+- **Cursor flickering** when navigating source directories: Changed `Renderer#render` from per-line `print` (immediate flush) to a single buffered `write` call — terminal updates are now atomic
+- **Navigation lag** when moving between source files: `bat` is now executed asynchronously in a background thread; the current frame immediately falls back to plain text, then re-renders with highlighting on completion
+
+### Changed
+- **`Renderer#render`**: Replaced row-by-row `print` with single `write(buf)` + `flush` for atomic output
+- **`SyntaxHighlighter`**: Added `highlight_async` (Thread + Mutex + pending guard) alongside existing `highlight`
+- **`TerminalUI`**: Preview caching extended with `highlighted` / `highlighted_wrapped` keys; `@highlight_updated` flag added for async re-render notification
+- **`FilePreview#determine_file_type`**: Added Go, Rust, Shell, TOML, SQL, C, C++, Java, Dockerfile, Makefile language detection
+
+### Technical Details
+- **New files**: `lib/rufio/ansi_line_parser.rb`, `lib/rufio/syntax_highlighter.rb`
+- **Modified files**: `lib/rufio/renderer.rb`, `lib/rufio/terminal_ui.rb`, `lib/rufio/file_preview.rb`, `lib/rufio/health_checker.rb`, `lib/rufio/config.rb`, `lib/rufio.rb`
+- **For details**: [CHANGELOG_v0.80.0.md](./docs/CHANGELOG_v0.80.0.md)
+
+## [0.71.0] - 2026-02-16
+
+### Added
+- **Script Arguments**: Pass arguments to scripts via command mode (e.g., `@retag.sh v0.70.0`)
+  - Supports both ScriptRunner and LocalScriptScanner
+- **Script/Rake Execution Logging**: Log execution results of `@script` and `rake:task` commands to CommandLogger
+  - Covers both synchronous and background execution
+
+### Fixed
+- **Selection across directories**: Clear selection state when navigating to a different directory
+- **Help/Log viewer entries**: Exclude `..` entry in help mode and log viewer mode
+
 ## [0.70.0] - 2026-02-14
 
 ### Added
@@ -599,6 +637,7 @@ For detailed information, see [CHANGELOG_v0.4.0.md](./docs/CHANGELOG_v0.4.0.md)
 
 ### Detailed Release Notes
 
+- [v0.80.0](./docs/CHANGELOG_v0.80.0.md) - Syntax Highlighting & Rendering Fixes
 - [v0.31.0](./docs/CHANGELOG_v0.31.0.md) - Experimental Native Scanner Implementation
 - [v0.30.0](./docs/CHANGELOG_v0.30.0.md) - Help System Overhaul
 - [v0.21.0](./docs/CHANGELOG_v0.21.0.md) - Copy Feature & Code Refactoring

data/README.md

@@ -40,7 +40,7 @@ rufio is not just a file manager. It's a **tool runtime execution environment**.
 ### As a File Manager
 
 - **Vim-like Key Bindings**: Intuitive navigation
-- **Real-time Preview**: Instantly display file contents
+- **Real-time Preview**: Instantly display file contents with syntax highlighting (via `bat`)
 - **Fast Search**: Integration with fzf/rga
 - **Bookmarks**: Quick access to frequently used directories
 - **zoxide Integration**: Smart directory history
@@ -290,22 +290,41 @@ script_paths:
 
 ## External Tool Integration
 
-rufio integrates with the following external tools to extend functionality:
+rufio integrates with the following external tools to extend functionality.
+All tools are **optional** — rufio works without them, falling back to built-in behavior.
 
-| Tool | Purpose | Key |
-|------|---------|-----|
-| fzf | File name search | `s` |
-| rga | File content search | `F` |
-| zoxide | Directory history | `z` |
+| Tool | Purpose | Key | Required? |
+|------|---------|-----|-----------|
+| fzf | File name search | `s` | Optional |
+| rga | File content search | `F` | Optional |
+| zoxide | Directory history | `z` | Optional |
+| bat | Syntax highlighting in preview | — | Optional |
 
-### Installation
+### bat — Syntax Highlighting
+
+When `bat` is installed, code files in the preview pane are displayed with full syntax
+highlighting (Ruby, Python, Go, Rust, TypeScript, and 15+ more languages).
+
+Highlighting is loaded asynchronously — navigation stays fast even on large source trees.
+
+```bash
+# macOS
+brew install bat
+
+# Ubuntu/Debian
+apt install bat
+```
+
+Run `rufio -c` to verify bat is detected correctly.
+
+### Installation (all tools)
 
 ```bash
 # macOS
-brew install fzf rga zoxide
+brew install fzf bat rga zoxide
 
 # Ubuntu/Debian
-apt install fzf zoxide
+apt install fzf bat zoxide
 # rga requires separate installation: https://github.com/phiresky/ripgrep-all
 ```
 

data/README_ja.md

@@ -42,7 +42,7 @@ rufioは単なるファイルマネージャーではありません。**ツー
 ### ファイルマネージャーとして
 
 - **Vimライクなキーバインド**: 直感的なナビゲーション
-- **リアルタイムプレビュー**: ファイル内容を即座に表示
+- **リアルタイムプレビュー**: ファイル内容を即座に表示（`bat` によるシンタックスハイライト対応）
 - **高速検索**: fzf/rgaとの連携
 - **ブックマーク**: よく使うディレクトリに素早くアクセス
 - **zoxide連携**: スマートなディレクトリ履歴
@@ -255,22 +255,42 @@ SCRIPT_PATHS = [
 
 ## 外部ツール連携
 
-rufioは以下の外部ツールと連携して機能を拡張します：
+rufioは以下の外部ツールと連携して機能を拡張します。
+すべて**オプション**です。インストールなしでも rufio は正常動作します。
 
-| ツール | 用途 | キー |
-|--------|------|------|
-| fzf | ファイル名検索 | `s` |
-| rga | ファイル内容検索 | `F` |
-| zoxide | ディレクトリ履歴 | `z` |
+| ツール | 用途 | キー | 必須 |
+|--------|------|------|------|
+| fzf | ファイル名検索 | `s` | オプション |
+| rga | ファイル内容検索 | `F` | オプション |
+| zoxide | ディレクトリ履歴 | `z` | オプション |
+| bat | プレビューのシンタックスハイライト | — | オプション |
 
-### インストール
+### bat — シンタックスハイライト
+
+`bat` をインストールすると、プレビューペインでコードファイルを開いた際に
+シンタックスハイライトが表示されます（Ruby、Python、Go、Rust、TypeScript など15言語以上対応）。
+
+ハイライトはバックグラウンドで非同期に読み込まれるため、大きなソースツリーでも
+カーソル移動が重くなりません。
+
+```bash
+# macOS
+brew install bat
+
+# Ubuntu/Debian
+apt install bat
+```
+
+`rufio -c` を実行すると bat が正しく認識されているか確認できます。
+
+### インストール（全ツール）
 
 ```bash
 # macOS
-brew install fzf rga zoxide
+brew install fzf bat rga zoxide
 
 # Ubuntu/Debian
-apt install fzf zoxide
+apt install fzf bat zoxide
 # rgaは別途インストール: https://github.com/phiresky/ripgrep-all
 ```
 

data/docs/CHANGELOG_v0.80.0.md

@@ -0,0 +1,189 @@
+# CHANGELOG v0.80.0
+
+## Overview
+
+Adds syntax highlighting to the file preview pane. When `bat` is installed, code files
+are displayed with full ANSI color highlighting. Environments without `bat` fall back
+silently to plain text display.
+
+Also fixes **cursor flickering** and **navigation lag** that occurred when browsing
+source code directories with highlighting active.
+
+---
+
+## New Features
+
+### Syntax Highlighting (via `bat`)
+
+The preview pane now renders code files with syntax highlighting using `bat`'s ANSI
+color output.
+
+**Supported languages:**
+
+| Language | Extensions |
+|----------|------------|
+| Ruby | `.rb` |
+| Python | `.py` |
+| JavaScript | `.js`, `.mjs` |
+| TypeScript | `.ts` |
+| HTML | `.html`, `.htm` |
+| CSS | `.css` |
+| JSON | `.json` |
+| YAML | `.yml`, `.yaml` |
+| Markdown | `.md`, `.markdown` |
+| Go | `.go` |
+| Rust | `.rs` |
+| Shell | `.sh`, `.bash`, `.zsh` |
+| TOML | `.toml` |
+| SQL | `.sql` |
+| C | `.c`, `.h` |
+| C++ | `.cpp`, `.cc`, `.cxx`, `.hpp` |
+| Java | `.java` |
+| Dockerfile | `Dockerfile`, `Dockerfile.*` |
+| Makefile | `Makefile`, `GNUmakefile` |
+
+**Behavior:**
+- Graceful degradation — plain text display when `bat` is not installed
+- Non-UTF-8 files (e.g. Shift_JIS) skip highlighting automatically
+- mtime-based cache: second visit to the same file is instant (0 ms)
+- Run `rufio -c` to verify `bat` is detected by the health checker
+
+**Installation:**
+```bash
+# macOS
+brew install bat
+
+# Ubuntu/Debian
+apt install bat
+```
+
+---
+
+## Bug Fixes
+
+### Fix 1: Cursor Flickering (Renderer Atomic Output)
+
+**Symptom:** The preview pane flickered briefly when moving the cursor in source
+code directories.
+
+**Root cause:** `Renderer#render` called `print` once per dirty row. With
+`STDOUT sync=true`, each `print` flushes immediately, so intermediate states
+(highlighted color removed, new color not yet drawn) were visible in the terminal.
+
+**Fix:** All dirty row output is now accumulated into a single string buffer, then
+written with one `write` + `flush` call — guaranteeing an atomic terminal update.
+
+```
+Before: print row0 → flush → print row1 → flush → ...  (intermediate states visible)
+After:  buf = row0 + row1 + ...  →  write(buf) + flush  (single atomic update)
+```
+
+### Fix 2: Navigation Lag (Async bat Execution)
+
+**Symptom:** Moving the cursor to a new file in a source directory caused 10–30 ms
+of lag, making navigation feel sluggish.
+
+**Root cause:** `SyntaxHighlighter#highlight` called `IO.popen(['bat', ...])` synchronously
+inside the main loop. The bat process startup cost blocked the frame on every new file visit.
+
+**Fix:** Added `highlight_async` which runs `bat` in a background Thread.
+
+- The frame immediately after moving to a new file displays plain text (instant fallback)
+- When the background thread completes, it sets `@highlight_updated = true`
+- The main loop detects the flag and triggers a re-render with highlighting
+- A pending guard prevents duplicate threads for the same file path
+- A `Mutex` protects all cache reads/writes for thread safety
+
+---
+
+## Technical Details
+
+### New Files
+
+| File | Description |
+|------|-------------|
+| `lib/rufio/ansi_line_parser.rb` | Parses ANSI SGR escape sequences into token arrays. Full-width character-aware wrapping |
+| `lib/rufio/syntax_highlighter.rb` | Wraps the `bat` command. mtime cache, async execution, Mutex protection |
+| `test/test_ansi_line_parser.rb` | Unit tests for AnsiLineParser (25 tests) |
+| `test/test_syntax_highlighter.rb` | Unit tests for SyntaxHighlighter (16 tests) |
+
+### Modified Files
+
+| File | Change |
+|------|--------|
+| `lib/rufio/renderer.rb` | Per-line `print` → single `write(buf)` + `flush` |
+| `lib/rufio/terminal_ui.rb` | Added `@syntax_highlighter`, highlighting branch in `draw_file_preview_to_buffer`, `@highlight_updated` check in main loop |
+| `lib/rufio/file_preview.rb` | Extended `determine_file_type` with Go, Rust, Shell, TOML, SQL, C, C++, Java, Dockerfile, Makefile |
+| `lib/rufio/health_checker.rb` | Added `check_bat` method |
+| `lib/rufio/config.rb` | Added `health.bat` message key (EN + JA) |
+| `lib/rufio.rb` | Added `require` for `ansi_line_parser` and `syntax_highlighter` |
+| `test/test_renderer.rb` | Added `OutputSpy` helper, 2 new atomic output tests |
+
+### Architecture
+
+```
+bat (external process)
+    ↓  IO.popen — background Thread
+SyntaxHighlighter#highlight_async
+    ↓  callback on completion
+@preview_cache[path][:highlighted] = lines   # store ANSI line array
+@highlight_updated = true                     # notify main loop
+    ↓  next frame
+AnsiLineParser.parse(line)                   # ANSI → token array
+AnsiLineParser.wrap(tokens, width)           # full-width-aware wrapping
+draw_highlighted_line_to_buffer(screen, ...) # per-char fg: color drawing
+```
+
+### Preview Cache Structure
+
+```ruby
+@preview_cache[file_path] = {
+  content:             Array<String>,                # plain text lines
+  preview_data:        Hash,                         # type, encoding, etc.
+  highlighted:         nil | false | Array<String>,
+  #                    nil   = not yet requested
+  #                    false = requested, awaiting background result
+  #                    Array = ANSI lines ready to render
+  wrapped:             Hash,                         # width => wrapped plain lines
+  highlighted_wrapped: Hash                          # width => wrapped token arrays
+}
+```
+
+---
+
+## Tests
+
+All tests pass (pre-existing TestUISnapshot / TestBufferParity snapshot mismatches excluded):
+
+| Test file | Tests | Status |
+|-----------|-------|--------|
+| `test_ansi_line_parser.rb` | 25 | new |
+| `test_syntax_highlighter.rb` | 16 (9 existing + 7 new) | pass |
+| `test_renderer.rb` | 12 (10 existing + 2 new) | pass |
+
+**34 new tests** added in this release.
+
+---
+
+## Dependencies
+
+### New Optional External Tool
+
+| Tool | Purpose | Install |
+|------|---------|---------|
+| `bat` | Syntax highlighting | `brew install bat` / `apt install bat` |
+
+rufio works normally without `bat` — plain text preview is always available as a fallback.
+
+---
+
+## Health Check
+
+Use `rufio -c` to verify `bat` installation:
+
+```
+rufio Health Check
+  ✓ bat (syntax highlight): bat 0.25.0 (2024-...)
+  ✗ bat (syntax highlight): not found
+      brew install bat   # optional: enables syntax highlighting
+```

data/lib/rufio/ansi_line_parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Rufio
+  # ANSI エスケープコード付きの行をトークン列に分解するモジュール。
+  # bat --color=always の出力をシンタックスハイライト表示するために使用する。
+  module AnsiLineParser
+    # SGR (Select Graphic Rendition) ANSI エスケープシーケンスにマッチするパターン
+    ANSI_SGR_PATTERN = /\e\[[0-9;]*m/
+
+    # ANSI 付き行を {text: String, fg: String|nil} のトークン配列に分解する。
+    #
+    # @param line [String] ANSI コードを含む可能性がある行
+    # @return [Array<Hash>] {text:, fg:} のトークン配列
+    def self.parse(line)
+      tokens = []
+      current_fg = nil
+
+      # ANSI SGR シーケンス、非エスケープ文字列、孤立エスケープの順にスキャン
+      line.scan(/#{ANSI_SGR_PATTERN}|[^\e]+|\e(?!\[)/) do |part|
+        if part.start_with?("\e[")
+          current_fg = apply_ansi_sequence(current_fg, part)
+        else
+          tokens << { text: part, fg: current_fg }
+        end
+      end
+
+      tokens
+    end
+
+    # トークン配列の表示幅（ANSI コードを除く）を計算する。
+    #
+    # @param tokens [Array<Hash>] parse が返したトークン配列
+    # @return [Integer] 表示幅
+    def self.display_width(tokens)
+      tokens.sum { |t| TextUtils.display_width(t[:text]) }
+    end
+
+    # トークン配列を max_width で折り返し、行ごとのトークン配列の配列を返す。
+    # 全角文字（日本語等）は幅2として扱う。
+    #
+    # @param tokens [Array<Hash>] parse が返したトークン配列
+    # @param max_width [Integer] 折り返し幅（表示幅基準）
+    # @return [Array<Array<Hash>>] 行ごとのトークン配列
+    def self.wrap(tokens, max_width)
+      return [] if tokens.empty? || max_width <= 0
+
+      lines = []
+      current_line = []
+      current_width = 0
+
+      tokens.each do |token|
+        fg = token[:fg]
+        current_text = String.new
+
+        token[:text].each_char do |char|
+          char_w = TextUtils.char_width(char)
+
+          if current_width + char_w > max_width
+            # 折り返し: 現在のテキストをトークンとして確定
+            current_line << { text: current_text, fg: fg } unless current_text.empty?
+            lines << current_line
+            current_line = []
+            current_text = String.new
+            current_width = 0
+          end
+
+          current_text << char
+          current_width += char_w
+        end
+
+        current_line << { text: current_text, fg: fg } unless current_text.empty?
+      end
+
+      lines << current_line unless current_line.empty?
+      lines
+    end
+
+    # private helper: ANSI シーケンスを適用して新しい fg 状態を返す。
+    # リセットシーケンスは nil を返す。
+    # 複合シーケンス（例: \e[0;32m）はリセット後の色だけを返す。
+    def self.apply_ansi_sequence(current_fg, seq)
+      # \e[ と m の間のコード文字列を取り出す
+      codes_str = seq[2..-2]
+      codes = codes_str.split(';')
+
+      # すべてのコードがリセット（"0" or ""）ならリセット
+      if codes.empty? || codes.all? { |c| c.empty? || c == '0' }
+        return nil
+      end
+
+      # 先頭がリセットコードで後続に色指定がある場合（例: \e[0;32m）
+      if codes.first.empty? || codes.first == '0'
+        remaining = codes.drop_while { |c| c.empty? || c == '0' }
+        return remaining.empty? ? nil : "\e[#{remaining.join(';')}m"
+      end
+
+      # 通常の色/属性コード → そのまま使用
+      seq
+    end
+
+    private_class_method :apply_ansi_sequence
+  end
+end

data/lib/rufio/command_mode.rb

@@ -28,7 +28,8 @@ module Rufio
       @job_manager = job_manager
       @script_runner = ScriptRunner.new(
         script_paths: script_paths,
-        job_manager: job_manager
+        job_manager: job_manager,
+        command_logger: @background_executor&.command_logger
       )
     end
 
@@ -41,7 +42,8 @@ module Rufio
       # ScriptRunnerも設定（ScriptPathManagerのパスを使用）
       @script_runner = ScriptRunner.new(
         script_paths: @script_path_manager.paths,
-        job_manager: job_manager
+        job_manager: job_manager,
+        command_logger: @background_executor&.command_logger
       )
     end
 
@@ -237,22 +239,27 @@ module Rufio
 
     # スクリプトを実行する（@プレフィックス用）
     # ScriptRunner → LocalScriptScanner の順にフォールバック
-    # @param script_name [String] スクリプト名
+    # @param script_input [String] スクリプト名（引数を含む場合あり）
     # @param working_dir [String, nil] 作業ディレクトリ
     # @return [String] 実行結果メッセージ
-    def execute_script(script_name, working_dir)
+    def execute_script(script_input, working_dir)
       working_dir ||= Dir.pwd
 
+      # スクリプト名と引数を分離（例: "retag.sh v0.70.0" → name="retag.sh", args="v0.70.0"）
+      parts = script_input.split(' ', 2)
+      script_name = parts[0]
+      script_args = parts[1]
+
       # ScriptRunnerで検索
       if @script_runner
-        job = @script_runner.run(script_name, working_dir: working_dir)
+        job = @script_runner.run(script_name, working_dir: working_dir, args: script_args)
         return "🚀 ジョブを開始: #{script_name}" if job
       end
 
       # LocalScriptScannerにフォールバック
       local_script = @local_script_scanner.find_script(script_name)
       if local_script
-        return execute_local_script(local_script, working_dir)
+        return execute_local_script(local_script, working_dir, script_args)
       end
 
       # どちらにも見つからない
@@ -266,33 +273,57 @@ module Rufio
     # ローカルスクリプトを実行する
     # @param script [Hash] スクリプト情報 { name:, path:, dir: }
     # @param working_dir [String] 作業ディレクトリ
-    # @return [String] 実行結果メッセージ
-    def execute_local_script(script, working_dir)
+    # @param args [String, nil] スクリプトに渡す引数
+    # @return [String, Hash] 実行結果メッセージ
+    def execute_local_script(script, working_dir, args = nil)
+      command = build_script_command(script)
+      command = "#{command} #{args}" if args && !args.empty?
+
       if @job_manager
         job = @job_manager.add_job(
           name: script[:name],
           path: working_dir,
-          command: build_script_command(script)
+          command: command
         )
         job.start
 
         Thread.new do
-          execute_script_in_background(job, script, working_dir)
+          execute_script_in_background(job, script, working_dir, command)
         end
 
         "🚀 ジョブを開始: #{script[:name]}"
       else
         # 同期実行
-        command = build_script_command(script)
         stdout, stderr, status = Open3.capture3(command, chdir: working_dir)
-        {
+        result = {
           success: status.success?,
           output: stdout.strip,
           stderr: stderr.strip
         }
+
+        # Logsに記録
+        log_execution("@#{script[:name]}", result)
+
+        result
       end
     end
 
+    # 実行結果をCommandLoggerに記録
+    # @param command_name [String] コマンド名
+    # @param result [Hash] 実行結果 { success:, output:, stderr:, error: }
+    def log_execution(command_name, result)
+      logger = @background_executor&.command_logger
+      return unless logger
+
+      output = [result[:output], result[:stderr]].compact.reject(&:empty?).join("\n")
+      logger.log(
+        command_name,
+        output,
+        success: result[:success],
+        error: result[:error]
+      )
+    end
+
     # スクリプトの実行コマンドを構築
     # @param script [Hash] スクリプト情報
     # @return [String] 実行コマンド
@@ -319,8 +350,7 @@ module Rufio
     end
 
     # ローカルスクリプトをバックグラウンドで実行
-    def execute_script_in_background(job, script, working_dir)
-      command = build_script_command(script)
+    def execute_script_in_background(job, script, working_dir, command)
       stdout, stderr, status = Open3.capture3(command, chdir: working_dir)
 
       job.append_log(stdout) unless stdout.empty?
@@ -332,10 +362,18 @@ module Rufio
         job.fail(exit_code: status.exitstatus)
       end
 
+      # Logsに記録
+      log_execution("@#{script[:name]}", {
+        success: status.success?,
+        output: stdout.strip,
+        stderr: stderr.strip
+      })
+
       @job_manager&.notify_completion(job)
     rescue StandardError => e
       job.append_log("Error: #{e.message}")
       job.fail(exit_code: -1)
+      log_execution("@#{script[:name]}", { success: false, output: '', stderr: e.message })
       @job_manager&.notify_completion(job)
     end
 
@@ -368,11 +406,18 @@ module Rufio
           result[:error] = "コマンドが失敗しました (終了コード: #{status.exitstatus})"
         end
 
+        # Logsに記録
+        log_execution("rake:#{task_name}", result)
+
         result
       rescue Errno::ENOENT => e
-        { success: false, error: "rakeが見つかりません: #{e.message}" }
+        result = { success: false, error: "rakeが見つかりません: #{e.message}" }
+        log_execution("rake:#{task_name}", result)
+        result
       rescue StandardError => e
-        { success: false, error: "rake実行エラー: #{e.message}" }
+        result = { success: false, error: "rake実行エラー: #{e.message}" }
+        log_execution("rake:#{task_name}", result)
+        result
       end
     end
 

data/lib/rufio/config.rb

@@ -66,6 +66,7 @@ module Rufio
         'health.fzf' => 'fzf (file search)',
         'health.rga' => 'rga (content search)',
         'health.zoxide' => 'zoxide (directory history)',
+        'health.bat' => 'bat (syntax highlight)',
         'health.file_opener' => 'System file opener',
         'health.summary' => 'Summary:',
         'health.ok' => 'OK',
@@ -135,6 +136,7 @@ module Rufio
         'health.fzf' => 'fzf (file search)',
         'health.rga' => 'rga (content search)',
         'health.zoxide' => 'zoxide (directory history)',
+        'health.bat' => 'bat (syntax highlight)',
         'health.file_opener' => 'System file opener',
         'health.summary' => 'Summary:',
         'health.ok' => 'OK',

data/lib/rufio/file_preview.rb

@@ -127,7 +127,16 @@ module Rufio
 
     def determine_file_type(file_path)
       extension = File.extname(file_path).downcase
-      
+      basename = File.basename(file_path)
+
+      # 拡張子なしファイル名での判定（Dockerfile 等）
+      case basename
+      when "Dockerfile", /\ADockerfile\./
+        return { type: "code", language: "dockerfile" }
+      when "Makefile", "GNUmakefile"
+        return { type: "code", language: "makefile" }
+      end
+
       case extension
       when ".rb"
         { type: "code", language: "ruby" }
@@ -147,6 +156,22 @@ module Rufio
         { type: "code", language: "yaml" }
       when ".md", ".markdown"
         { type: "code", language: "markdown" }
+      when ".go"
+        { type: "code", language: "go" }
+      when ".rs"
+        { type: "code", language: "rust" }
+      when ".sh", ".bash", ".zsh"
+        { type: "code", language: "shell" }
+      when ".toml"
+        { type: "code", language: "toml" }
+      when ".sql"
+        { type: "code", language: "sql" }
+      when ".c", ".h"
+        { type: "code", language: "c" }
+      when ".cpp", ".cc", ".cxx", ".hpp"
+        { type: "code", language: "cpp" }
+      when ".java"
+        { type: "code", language: "java" }
       when ".txt", ".log"
         { type: "text", language: nil }
       when ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z"

data/lib/rufio/health_checker.rb

@@ -21,6 +21,7 @@ module Rufio
         { name: ConfigLoader.message('health.fzf'), method: :check_fzf },
         { name: ConfigLoader.message('health.rga'), method: :check_rga },
         { name: ConfigLoader.message('health.zoxide'), method: :check_zoxide },
+        { name: ConfigLoader.message('health.bat'), method: :check_bat },
         { name: ConfigLoader.message('health.file_opener'), method: :check_file_opener }
       ]
 
@@ -136,6 +137,23 @@ module Rufio
       end
     end
 
+    def check_bat
+      if system("which bat > /dev/null 2>&1")
+        version = `bat --version 2>/dev/null`.strip
+        {
+          status: :ok,
+          message: version,
+          details: nil
+        }
+      else
+        {
+          status: :warning,
+          message: "bat #{ConfigLoader.message('health.tool_not_found')}",
+          details: install_instruction_for('bat')
+        }
+      end
+    end
+
     def check_file_opener
       case RUBY_PLATFORM
       when /darwin/
@@ -180,6 +198,8 @@ module Rufio
           "#{ConfigLoader.message('health.install_brew')} rga"
         when 'zoxide'
           "#{ConfigLoader.message('health.install_brew')} zoxide"
+        when 'bat'
+          "#{ConfigLoader.message('health.install_brew')} bat  # optional: syntax highlight"
         end
       when /linux/
         case tool
@@ -189,6 +209,8 @@ module Rufio
           ConfigLoader.message('health.rga_releases')
         when 'zoxide'
           "#{ConfigLoader.message('health.install_apt')} zoxide (Ubuntu/Debian) or check your package manager"
+        when 'bat'
+          "#{ConfigLoader.message('health.install_apt')} bat (Ubuntu/Debian) or check your package manager  # optional: syntax highlight"
         end
       else
         ConfigLoader.message('health.install_guide')

data/lib/rufio/keybind_handler.rb

@@ -218,10 +218,15 @@ module Rufio
     end
 
     def get_active_entries
-      if @filter_manager.filter_active?
-        @filter_manager.filtered_entries
+      entries = if @filter_manager.filter_active?
+                  @filter_manager.filtered_entries
+                else
+                  @directory_listing&.list_entries || []
+                end
+      if @in_help_mode || @in_log_viewer_mode
+        entries.reject { |e| e[:name] == '..' }
       else
-        @directory_listing&.list_entries || []
+        entries
       end
     end
 

data/lib/rufio/renderer.rb

@@ -31,13 +31,17 @@ module Rufio
       end
 
       # Phase1: Only process dirty rows (rows that have changed)
+      # 全dirty rowsの出力を1つのバッファに積んでから単一の write() で書き出す。
+      # STDOUT sync=true 環境で print を行ごとに呼ぶと各行で即座にフラッシュされ
+      # 中間状態が表示されてちらつきが発生するため、アトミックな更新を保証する。
+      buf = String.new("")
       rendered_count = 0
       dirty.each do |y|
         line = screen.row(y)
         next if line == @front[y]  # Skip if content is actually the same
 
-        # Move cursor to line y (1-indexed) and output the line
-        @output.print "\e[#{y + 1};1H#{line}"
+        # Move cursor to line y (1-indexed) and buffer the line
+        buf << "\e[#{y + 1};1H#{line}"
         @front[y] = line
         rendered_count += 1
       end
@@ -45,8 +49,11 @@ module Rufio
       # Phase1: Clear dirty tracking after rendering
       screen.clear_dirty
 
-      # Only flush if we actually rendered something
-      @output.flush if rendered_count > 0
+      # 単一の write() でアトミックに出力し、その後 flush する
+      if rendered_count > 0
+        @output.write(buf)
+        @output.flush
+      end
 
       true
     end

data/lib/rufio/screen.rb

@@ -114,7 +114,8 @@ module Rufio
       return " " * @width if y < 0 || y >= @height
 
       # Phase1: Pre-allocate string capacity for better performance
-      result = String.new(capacity: @width * 20)
+      # String.new("", capacity: N) inherits UTF-8 encoding from ""; String.new(capacity: N) creates ASCII-8BIT
+      result = String.new("", capacity: @width * 20)
       current_width = 0  # Phase1: Accumulate width from cells (no recalculation)
 
       # オーバーレイがある場合はベース + オーバーレイを合成
@@ -281,7 +282,7 @@ module Rufio
       return char if fg.nil? && bg.nil?
 
       # Phase1: String builder with pre-allocated capacity (no array generation)
-      result = String.new(capacity: 30)
+      result = String.new("", capacity: 30)
       result << fg if fg
       result << bg if bg
       result << char

data/lib/rufio/script_runner.rb

@@ -11,9 +11,11 @@ module Rufio
 
     # @param script_paths [Array<String>] スクリプトを検索するディレクトリのリスト
     # @param job_manager [JobManager, nil] ジョブマネージャー（nilの場合は同期実行）
-    def initialize(script_paths:, job_manager: nil)
+    # @param command_logger [CommandLogger, nil] コマンドロガー
+    def initialize(script_paths:, job_manager: nil, command_logger: nil)
       @script_paths = script_paths.map { |p| File.expand_path(p) }
       @job_manager = job_manager
+      @command_logger = command_logger
       @scripts_cache = nil
     end
 
@@ -54,15 +56,16 @@ module Rufio
     # スクリプトをジョブとして実行
     # @param name [String] スクリプト名
     # @param working_dir [String] 作業ディレクトリ
+    # @param args [String, nil] スクリプトに渡す引数
     # @param selected_file [String, nil] 選択中のファイル
     # @param selected_dir [String, nil] 選択中のディレクトリ
     # @return [TaskStatus, nil] 作成されたジョブ、またはスクリプトが見つからない場合nil
-    def run(name, working_dir:, selected_file: nil, selected_dir: nil)
+    def run(name, working_dir:, args: nil, selected_file: nil, selected_dir: nil)
       script = find_script(name)
       return nil unless script
 
       env = build_environment(working_dir, selected_file, selected_dir)
-      execute_script(script, working_dir, env)
+      execute_script(script, working_dir, env, args)
     end
 
     # キャッシュをクリア
@@ -130,9 +133,11 @@ module Rufio
     # @param script [Hash] スクリプト情報
     # @param working_dir [String] 作業ディレクトリ
     # @param env [Hash] 環境変数
+    # @param args [String, nil] スクリプトに渡す引数
     # @return [TaskStatus] 作成されたジョブ
-    def execute_script(script, working_dir, env = {})
+    def execute_script(script, working_dir, env = {}, args = nil)
       command = build_command(script)
+      command = "#{command} #{args}" if args && !args.empty?
 
       if @job_manager
         # ジョブマネージャーにジョブを追加
@@ -205,12 +210,24 @@ module Rufio
         job.fail(exit_code: status.exitstatus)
       end
 
+      # CommandLoggerに記録
+      log_to_command_logger(job.name, stdout, stderr, status.success?)
+
       # 通知を送信
       @job_manager&.notify_completion(job)
     rescue StandardError => e
       job.append_log("Error: #{e.message}")
       job.fail(exit_code: -1)
+      log_to_command_logger(job.name, '', e.message, false)
       @job_manager&.notify_completion(job)
     end
+
+    # CommandLoggerに実行結果を記録
+    def log_to_command_logger(name, stdout, stderr, success)
+      return unless @command_logger
+
+      output = [stdout, stderr].compact.map(&:strip).reject(&:empty?).join("\n")
+      @command_logger.log("@#{name}", output, success: success)
+    end
   end
 end

data/lib/rufio/selection_manager.rb

@@ -17,6 +17,12 @@ module Rufio
     def toggle_selection(entry, current_directory = nil)
       return false unless entry
 
+      # 異なるディレクトリで選択した場合、古い選択をクリアしてリセット
+      if current_directory && @source_directory && current_directory != @source_directory
+        @selected_items.clear
+        @source_directory = nil
+      end
+
       if @selected_items.include?(entry[:name])
         @selected_items.delete(entry[:name])
         # Clear source_directory if no items are selected

data/lib/rufio/syntax_highlighter.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Rufio
+  # bat コマンドを使ってファイルのシンタックスハイライトを行うクラス。
+  # bat が存在しない場合は available? が false を返し、highlight は [] を返す。
+  # mtime ベースのキャッシュを持ち、同じファイルの2回目以降は0msで返す。
+  class SyntaxHighlighter
+    def initialize
+      @bat_available = bat_available?
+      @cache = {}    # file_path => { mtime: Time, lines: Array<String> }
+      @pending = {}  # file_path => true（非同期実行中フラグ）
+      @mutex = Mutex.new
+    end
+
+    # bat コマンドが利用可能かどうか
+    #
+    # @return [Boolean]
+    def available?
+      @bat_available
+    end
+
+    # ファイルをシンタックスハイライトして ANSI 付き行の配列を返す（同期版）。
+    # bat が使えない場合、ファイルが存在しない場合は []。
+    #
+    # @param file_path [String] ハイライト対象のファイルパス
+    # @param max_lines [Integer] 取得する最大行数
+    # @return [Array<String>] ANSI エスケープコード付きの行配列
+    def highlight(file_path, max_lines: 50)
+      return [] unless @bat_available
+      return [] unless File.exist?(file_path)
+
+      mtime = File.mtime(file_path)
+      @mutex.synchronize do
+        cache = @cache[file_path]
+        return cache[:lines] if cache && cache[:mtime] == mtime
+      end
+
+      lines = run_bat(file_path, max_lines)
+      @mutex.synchronize { @cache[file_path] = { mtime: mtime, lines: lines } }
+      lines
+    rescue => _e
+      []
+    end
+
+    # ファイルをバックグラウンドスレッドでシンタックスハイライトする（非同期版）。
+    # メインループをブロックせず、bat 完了時にコールバックを呼ぶ。
+    # キャッシュヒット時はコールバックを即時（同期的に）呼ぶ。
+    # 同一ファイルへの重複呼び出しは無視する（ペンディングガード）。
+    #
+    # @param file_path [String] ハイライト対象のファイルパス
+    # @param max_lines [Integer] 取得する最大行数
+    # @yieldparam lines [Array<String>] ANSI付き行配列（エラー時は []）
+    def highlight_async(file_path, max_lines: 50, &callback)
+      return unless @bat_available
+      return unless File.exist?(file_path)
+
+      mtime = File.mtime(file_path)
+
+      @mutex.synchronize do
+        # キャッシュヒット → 即時コールバック
+        cache = @cache[file_path]
+        if cache && cache[:mtime] == mtime
+          callback&.call(cache[:lines])
+          return
+        end
+
+        # 既にペンディング中 → 重複スレッドを立てない
+        return if @pending[file_path]
+
+        @pending[file_path] = true
+      end
+
+      Thread.new do
+        begin
+          lines = run_bat(file_path, max_lines)
+          @mutex.synchronize do
+            @cache[file_path] = { mtime: mtime, lines: lines }
+            @pending.delete(file_path)
+          end
+          callback&.call(lines)
+        rescue => _e
+          @mutex.synchronize { @pending.delete(file_path) }
+          callback&.call([])
+        end
+      end
+
+      nil
+    end
+
+    private
+
+    def bat_available?
+      system('which bat > /dev/null 2>&1')
+    end
+
+    def run_bat(file_path, max_lines)
+      output = IO.popen(
+        ['bat', '--color=always', '--plain', '--line-range', "1:#{max_lines}", file_path],
+        err: File::NULL
+      ) { |io| io.read }
+
+      return [] unless output
+
+      output
+        .encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+        .split("\n")
+    rescue => _e
+      []
+    end
+  end
+end

data/lib/rufio/terminal_ui.rb

@@ -66,6 +66,11 @@ module Rufio
       @preview_cache = {}
       @last_preview_path = nil
 
+      # シンタックスハイライター（bat が利用可能な場合のみ動作）
+      @syntax_highlighter = SyntaxHighlighter.new
+      # 非同期ハイライト完了フラグ（Thread → メインループへの通知）
+      @highlight_updated = false
+
       # Footer cache (bookmark list)
       @cached_bookmarks = nil
       @cached_bookmark_time = nil
@@ -216,6 +221,7 @@ module Rufio
       last_frame_time = Time.now
       current_fps = 0.0
       last_fps_update = Time.now
+      @last_displayed_fps = 0.0
 
       # 再描画フラグ
       needs_redraw = false
@@ -237,8 +243,11 @@ module Rufio
             last_fps_update = start
           end
 
-          # test_modeでは毎フレーム描画してFPS計測の精度を上げる
-          needs_redraw = true
+          # FPS表示の更新タイミングで再描画（1秒ごと）
+          if current_fps != @last_displayed_fps
+            @last_displayed_fps = current_fps
+            needs_redraw = true
+          end
         end
 
         # UPDATE phase - ノンブロッキング入力処理
@@ -294,6 +303,12 @@ module Rufio
           needs_redraw = true
         end
 
+        # 非同期シンタックスハイライト完了チェック（バックグラウンドスレッドからの通知）
+        if @highlight_updated
+          @highlight_updated = false
+          needs_redraw = true
+        end
+
         # DRAW & RENDER phase - 変更があった場合のみ描画
         if needs_redraw
           # Screenバッファに描画（clearは呼ばない。必要な部分だけ更新）
@@ -825,14 +840,19 @@ module Rufio
       # プレビューコンテンツをキャッシュから取得（毎フレームのファイルI/Oを回避）
       preview_content = nil
       wrapped_lines = nil
+      highlighted_wrapped_lines = nil
 
       if selected_entry && selected_entry[:type] == 'file'
         # キャッシュチェック: 選択ファイルが変わった場合のみプレビューを更新
         if @last_preview_path != selected_entry[:path]
-          preview_content = get_preview_content(selected_entry)
+          full_preview = @file_preview.preview_file(selected_entry[:path])
+          preview_content = extract_preview_lines(full_preview)
           @preview_cache[selected_entry[:path]] = {
             content: preview_content,
-            wrapped: {}  # 幅ごとにキャッシュ
+            preview_data: full_preview,
+            highlighted: nil,       # nil = 未取得
+            wrapped: {},
+            highlighted_wrapped: {}
           }
           @last_preview_path = selected_entry[:path]
         else
@@ -841,8 +861,49 @@ module Rufio
           preview_content = cache_entry[:content] if cache_entry
         end
 
-        # 折り返し処理もキャッシュ
-        if preview_content && safe_width > 0
+        # bat が利用可能な場合はシンタックスハイライトを取得（非同期）
+        if @syntax_highlighter&.available? && preview_content
+          cache_entry = @preview_cache[selected_entry[:path]]
+          if cache_entry
+            preview_data = cache_entry[:preview_data]
+            if preview_data && preview_data[:type] == 'code' && preview_data[:encoding] == 'UTF-8'
+              # ハイライト行を未取得なら非同期で bat を呼び出す
+              # nil = 未リクエスト、false = リクエスト済み（結果待ち）、Array = 取得済み
+              if cache_entry[:highlighted].nil?
+                # 即座に false をセットしてペンディング状態にする（重複リクエスト防止）
+                cache_entry[:highlighted] = false
+                file_path = selected_entry[:path]
+                @syntax_highlighter.highlight_async(file_path) do |lines|
+                  # バックグラウンドスレッドからキャッシュを更新
+                  if (ce = @preview_cache[file_path])
+                    ce[:highlighted] = lines
+                    ce[:highlighted_wrapped] = {}  # 折り返しキャッシュをクリア
+                  end
+                  @highlight_updated = true  # メインループに再描画を通知
+                end
+                # このフレームはプレーンテキストで表示（次フレームでハイライト表示）
+              end
+
+              highlighted = cache_entry[:highlighted]
+              if highlighted.is_a?(Array) && !highlighted.empty? && safe_width > 0
+                if cache_entry[:highlighted_wrapped][safe_width]
+                  highlighted_wrapped_lines = cache_entry[:highlighted_wrapped][safe_width]
+                else
+                  # 各ハイライト行をトークン化して折り返す
+                  hl_wrapped = highlighted.flat_map do |hl_line|
+                    tokens = AnsiLineParser.parse(hl_line)
+                    tokens.empty? ? [[]] : AnsiLineParser.wrap(tokens, safe_width - 1)
+                  end
+                  cache_entry[:highlighted_wrapped][safe_width] = hl_wrapped
+                  highlighted_wrapped_lines = hl_wrapped
+                end
+              end
+            end
+          end
+        end
+
+        # プレーンテキストの折り返し（ハイライトなしのフォールバック）
+        if preview_content && safe_width > 0 && highlighted_wrapped_lines.nil?
           cache_entry = @preview_cache[selected_entry[:path]]
           if cache_entry && cache_entry[:wrapped][safe_width]
             wrapped_lines = cache_entry[:wrapped][safe_width]
@@ -853,48 +914,55 @@ module Rufio
         end
       end
 
+      content_x = cursor_position + 1
+
       (0...height).each do |i|
         line_num = i + CONTENT_START_LINE
 
         # 区切り線
         screen.put(cursor_position, line_num, '│')
 
-        content_to_print = ''
+        next if safe_width <= 0
 
         if selected_entry && i == 0
           # プレビューヘッダー
           header = " #{selected_entry[:name]} "
-          if @keybind_handler&.preview_focused?
-            header += "[PREVIEW MODE]"
-          end
-          content_to_print = header
-        elsif wrapped_lines && i >= 2
-          # ファイルプレビュー（折り返し対応）
+          header += "[PREVIEW MODE]" if @keybind_handler&.preview_focused?
+          header = TextUtils.truncate_to_width(header, safe_width) if TextUtils.display_width(header) > safe_width
+          remaining_space = safe_width - TextUtils.display_width(header)
+          header += ' ' * remaining_space if remaining_space > 0
+          screen.put_string(content_x, line_num, header)
+
+        elsif i >= 2 && highlighted_wrapped_lines
+          # シンタックスハイライト付きコンテンツ
           scroll_offset = @keybind_handler&.preview_scroll_offset || 0
           display_line_index = i - 2 + scroll_offset
 
-          if display_line_index < wrapped_lines.length
-            line = wrapped_lines[display_line_index] || ''
-            content_to_print = " #{line}"
+          if display_line_index < highlighted_wrapped_lines.length
+            draw_highlighted_line_to_buffer(screen, content_x, line_num,
+                                            highlighted_wrapped_lines[display_line_index], safe_width)
           else
-            content_to_print = ' '
+            screen.put_string(content_x, line_num, ' ' * safe_width)
           end
-        else
-          content_to_print = ' '
-        end
-
-        # safe_widthを超えないよう切り詰め
-        next if safe_width <= 0
 
-        if TextUtils.display_width(content_to_print) > safe_width
-          content_to_print = TextUtils.truncate_to_width(content_to_print, safe_width)
-        end
+        elsif i >= 2 && wrapped_lines
+          # プレーンテキストコンテンツ
+          scroll_offset = @keybind_handler&.preview_scroll_offset || 0
+          display_line_index = i - 2 + scroll_offset
 
-        # パディングを追加
-        remaining_space = safe_width - TextUtils.display_width(content_to_print)
-        content_to_print += ' ' * remaining_space if remaining_space > 0
+          content_to_print = if display_line_index < wrapped_lines.length
+                               " #{wrapped_lines[display_line_index] || ''}"
+                             else
+                               ' '
+                             end
+          content_to_print = TextUtils.truncate_to_width(content_to_print, safe_width) if TextUtils.display_width(content_to_print) > safe_width
+          remaining_space = safe_width - TextUtils.display_width(content_to_print)
+          content_to_print += ' ' * remaining_space if remaining_space > 0
+          screen.put_string(content_x, line_num, content_to_print)
 
-        screen.put_string(cursor_position + 1, line_num, content_to_print)
+        else
+          screen.put_string(content_x, line_num, ' ' * safe_width)
+        end
       end
     end
 
@@ -990,6 +1058,13 @@ module Rufio
       return [] unless entry && entry[:type] == 'file'
 
       preview = @file_preview.preview_file(entry[:path])
+      extract_preview_lines(preview)
+    rescue StandardError
+      ["(#{ConfigLoader.message('file.preview_error')})"]
+    end
+
+    # FilePreview の結果ハッシュからプレーンテキスト行を抽出する
+    def extract_preview_lines(preview)
       case preview[:type]
       when 'text', 'code'
         preview[:lines]
@@ -1004,6 +1079,36 @@ module Rufio
       ["(#{ConfigLoader.message('file.preview_error')})"]
     end
 
+    # ハイライト済みトークン列を1行分 Screen バッファに描画する
+    # 先頭に1スペースを追加し、残りをスペースで埋める
+    def draw_highlighted_line_to_buffer(screen, x, y, tokens, max_width)
+      current_x = x
+      max_x = x + max_width
+
+      # 先頭スペース
+      if current_x < max_x
+        screen.put(current_x, y, ' ')
+        current_x += 1
+      end
+
+      # トークンを描画
+      tokens&.each do |token|
+        break if current_x >= max_x
+        token[:text].each_char do |char|
+          char_w = TextUtils.char_width(char)
+          break if current_x + char_w > max_x
+          screen.put(current_x, y, char, fg: token[:fg])
+          current_x += char_w
+        end
+      end
+
+      # 残りをスペースで埋める
+      while current_x < max_x
+        screen.put(current_x, y, ' ')
+        current_x += 1
+      end
+    end
+
 
     def get_display_entries
       entries = if @keybind_handler.filter_active?

data/lib/rufio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufio
-  VERSION = '0.70.0'
+  VERSION = '0.80.0'
 end

data/lib/rufio.rb

@@ -16,6 +16,8 @@ require_relative 'rufio/dialog_renderer'
 require_relative 'rufio/text_utils'
 require_relative 'rufio/logger'
 require_relative 'rufio/keybind_handler'
+require_relative 'rufio/ansi_line_parser'
+require_relative 'rufio/syntax_highlighter'
 require_relative 'rufio/file_preview'
 require_relative 'rufio/terminal_ui'
 require_relative 'rufio/application'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rufio
 version: !ruby/object:Gem::Version
-  version: 0.70.0
+  version: 0.80.0
 platform: ruby
 authors:
 - masisz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-15 00:00:00.000000000 Z
+date: 2026-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -137,6 +137,7 @@ files:
 - docs/CHANGELOG_v0.6.0.md
 - docs/CHANGELOG_v0.7.0.md
 - docs/CHANGELOG_v0.8.0.md
+- docs/CHANGELOG_v0.80.0.md
 - docs/CHANGELOG_v0.9.0.md
 - examples/bookmarks.yml
 - examples/config.rb
@@ -145,6 +146,7 @@ files:
 - info/keybindings.md
 - info/welcome.md
 - lib/rufio.rb
+- lib/rufio/ansi_line_parser.rb
 - lib/rufio/application.rb
 - lib/rufio/async_scanner_fiber.rb
 - lib/rufio/async_scanner_promise.rb
@@ -191,6 +193,7 @@ files:
 - lib/rufio/script_runner.rb
 - lib/rufio/selection_manager.rb
 - lib/rufio/shell_command_completion.rb
+- lib/rufio/syntax_highlighter.rb
 - lib/rufio/tab_mode_manager.rb
 - lib/rufio/task_status.rb
 - lib/rufio/terminal_ui.rb