yildun 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: afdbd196693c266f7c4edf951aa39d8c2e750f15bccf1d500a0c00c7e94ea748
+  data.tar.gz: 5489e541a3cfbd946bef1441a03a7638b33f17ea02cef8669169c17ca6a25df3
+SHA512:
+  metadata.gz: bd3d9e22dfb587805f15b3e72149ad9513bf5090b22eee491ee25fa1cf2091140ade6936f1199adb2e997f103d4f787c16d4488f9aa8ca84f180f10fa96672ac
+  data.tar.gz: 4d6e49b08f6527baa7ee4caa78d66389219abf3d95477064776c2e4b84ead079dfa8b7ce8deb61957d5ef4e5c6f54280eedfb8e99900d0497517f71ce34c0686

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-09-21
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Yildun
+
+Yildun (δ Ursae Minoris, from Turkish *yıldız*, “star”) is a pure Ruby
+terminal application shell backed by the Tarazed terminal emulator.
+
+It provides profiles, tabs, pane state, keymaps, scrollback search, OSC 8
+links, and a deterministic headless mode for integration tests. It does not
+embed an SSH client, multiplexer, JavaScript engine, or WebView.
+
+## Installation
+
+```sh
+gem install yildun
+```
+
+## Headless sessions
+
+```sh
+yildun --headless --command 'printf "hello\\n"'
+```
+
+Configuration is read from `$XDG_CONFIG_HOME/yildun/settings.jsonc` (or
+`~/.config/yildun/settings.jsonc`). Settings are fail-safe: malformed files
+raise a clear error instead of silently changing the shell profile.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake test
+bundle exec rbs -I sig validate
+```

data/docs/adr/001-cell-rendering.md

@@ -0,0 +1,16 @@
+# 001: Cell rendering stays outside the element tree
+
+## Status
+
+Accepted
+
+## Decision
+
+Yildun keeps terminal cells in Tarazed's grid and exposes them to a dedicated
+view adapter. It does not turn every cell into a general UI element.
+
+## Consequences
+
+The terminal can apply damage updates without rebuilding an element tree. A
+future Zaniah window may consume the same grid while the headless executable
+remains usable without a graphics backend.

data/docs/adr/002-shell-integration.md

@@ -0,0 +1,16 @@
+# 002: Shell integration is a first-class feature
+
+## Status
+
+Accepted
+
+## Decision
+
+Yildun exposes Tarazed command records, failed-command filtering, cwd
+tracking, and previous/next command navigation instead of treating the PTY as
+an opaque byte stream.
+
+## Consequences
+
+The application can attach command navigation and output actions to a future
+window without duplicating OSC 133 parsing.

data/exe/yildun

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "yildun"
+
+options = {columns: 80, rows: 24, timeout: 0.2}
+OptionParser.new do |parser|
+  parser.banner = "Usage: yildun [options]"
+  parser.on("--command COMMAND", "shell command") { |value| options[:command] = value }
+  parser.on("--columns N", Integer) { |value| options[:columns] = value }
+  parser.on("--rows N", Integer) { |value| options[:rows] = value }
+  parser.on("--timeout SECONDS", Float) { |value| options[:timeout] = value }
+  parser.on("--headless", "print the terminal screen and exit") { options[:headless] = true }
+  parser.on("--script PATH", "send script contents to the shell") { |value| options[:script] = value }
+  parser.on("--expect PATH", "compare the headless screen with a file") { |value| options[:expect] = value }
+  parser.on("--version") { puts Yildun::VERSION; exit }
+end.parse!
+
+settings = Yildun::Settings.load
+profile = options[:command] ? Yildun::Profile.new("command", [options[:command]], {}, Dir.pwd) : Yildun.profile(settings)
+begin
+  app = Yildun::App.new(settings: settings, profile: profile, columns: options[:columns], rows: options[:rows])
+  terminal = app.active_terminal
+  terminal.input(File.binread(options[:script])) if options[:script]
+
+  if options[:headless]
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + options[:timeout]
+    terminal.pump(timeout: 0.05) while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline && terminal.session.alive?
+    output = terminal.screen.text
+    if options[:expect]
+      expected = File.read(options[:expect]).strip
+      abort "headless output did not match #{options[:expect]}" unless output.strip == expected
+    end
+    puts output
+  elsif STDIN.tty? && STDOUT.tty?
+    Yildun::Console.new(terminal).run
+  else
+    warn "Yildun needs a TTY for interactive mode; use --headless for scripted sessions."
+  end
+ensure
+  app&.active_tab&.close
+end

data/lib/yildun/app.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Yildun
+  class App
+    attr_reader :settings, :tabs, :active_index
+
+    def initialize(settings: Settings.new, profile: nil, columns: 80, rows: 24)
+      @settings, @tabs, @active_index = settings, [], 0
+      open_tab(profile: profile, columns: columns, rows: rows)
+    end
+
+    def active_tab = @tabs.fetch(@active_index)
+    def active_terminal = active_tab.terminal
+
+    def open_tab(profile: nil, cwd: Dir.pwd, columns: 80, rows: 24)
+      profile ||= Yildun.profile(@settings)
+      terminal = Terminal.new(command: profile.command, env: profile.env, cwd: profile.cwd || cwd,
+        columns: columns, rows: rows, scrollback_limit: @settings.fetch("scrollback_limit"))
+      @tabs << Tab.new(terminal, title: profile.name)
+      @active_index = @tabs.length - 1
+      active_tab
+    end
+
+    def open_tab_here(profile: nil, columns: 80, rows: 24)
+      open_tab(profile: profile, cwd: active_terminal.cwd, columns: columns, rows: rows)
+    end
+
+    def close_active
+      active_tab.close
+      @tabs.delete_at(@active_index)
+      return @active_index = 0 if @tabs.empty?
+
+      @active_index = [@active_index, @tabs.length - 1].min
+    end
+
+    def next_tab
+      @active_index = (@active_index + 1) % @tabs.length if @tabs.any?
+    end
+
+    def previous_tab
+      @active_index = (@active_index - 1) % @tabs.length if @tabs.any?
+    end
+  end
+end

data/lib/yildun/console.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module Yildun
+  class Console
+    def initialize(terminal, input: $stdin, output: $stdout)
+      @terminal, @input, @output = terminal, input, output
+    end
+
+    def run
+      return render unless @input.tty? && @output.tty? && @input.respond_to?(:raw)
+
+      @input.raw do
+        @output.write("\e[?25l")
+        loop do
+          resize
+          @terminal.pump(timeout: 0.02)
+          render
+          break unless @terminal.session.alive?
+          next unless IO.select([@input], nil, nil, 0.02)
+
+          @terminal.input(@input.read_nonblock(4096))
+        rescue IO::WaitReadable
+          retry
+        rescue EOFError, Errno::EIO
+          break
+        end
+      ensure
+        @output.write("\e[0m\e[?25h\e[H\e[2J")
+      end
+    end
+
+    def render
+      @output.write("\e[H")
+      @terminal.screen.lines.each { |line| @output.write("\e[2K#{line}\r\n") }
+      @output.flush
+    end
+
+    private
+
+    def resize
+      rows, columns = @output.winsize
+      @terminal.resize(columns: columns, rows: rows)
+    rescue SystemCallError, NoMethodError
+      nil
+    end
+  end
+end

data/lib/yildun/data_compat.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+unless defined?(Data)
+  Data = Struct
+  def Data.define(*members)
+    Struct.new(*members) do
+      members.each { |member| undef_method("#{member}=") }
+      define_method(:initialize) { |*values| super(*values).freeze }
+    end
+  end
+end

data/lib/yildun/keymap.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Yildun
+  class Keymap
+    def initialize(bindings = {})
+      @bindings = bindings.to_h.transform_keys(&:to_s).freeze
+    end
+
+    def command(key) = @bindings[key.to_s]
+    def include?(key) = @bindings.key?(key.to_s)
+    def to_h = @bindings
+  end
+end

data/lib/yildun/links.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Yildun
+  module Links
+    module_function
+
+    def at(screen, row, column, cwd: Dir.pwd)
+      screen.links(row).find { |link| column.between?(link[:column], link[:end_column] - 1) } ||
+        screen.file_paths(row, cwd: cwd).find { |link| column == link[:column] }
+    end
+
+    def open(url, opener: nil)
+      raise ArgumentError, "only http(s) and mailto links are allowed" unless url.to_s.match?(/\A(?:https?|mailto):/i)
+      return opener.call(url) if opener
+      command = RUBY_PLATFORM.match?(/darwin/) ? "open" : "xdg-open"
+      Process.spawn(command, url.to_s, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/yildun/pane.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Yildun
+  class Pane
+    attr_reader :children, :orientation
+
+    def initialize(tab = nil, orientation: :leaf)
+      @children, @orientation = tab ? [tab] : [], orientation
+    end
+
+    def leaf? = @orientation == :leaf
+    def split(tab, orientation: :horizontal)
+      if leaf? && @children.empty?
+        @children << (tab.is_a?(Pane) ? tab : Pane.new(tab))
+        return self
+      end
+
+      if leaf?
+        existing = @children.map { |child| child.is_a?(Pane) ? child : Pane.new(child) }
+        @children = existing
+      end
+      @orientation = orientation
+      @children << (tab.is_a?(Pane) ? tab : Pane.new(tab))
+      self
+    end
+  end
+end

data/lib/yildun/profile.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yildun
+  Profile = Data.define(:name, :command, :env, :cwd)
+
+  module_function
+
+  def profile(settings, name = settings.fetch("default_profile"))
+    value = settings.profile(name)
+    Profile.new(name.to_s, Array(value.fetch("command")), value.fetch("env", {}), value["cwd"])
+  end
+end

data/lib/yildun/search.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Yildun
+  class Search
+    def initialize(terminal) = @terminal = terminal
+    def call(query, regex: false) = @terminal.screen.search(query, regex: regex)
+  end
+end

data/lib/yildun/session.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Yildun
+  class SessionState
+    def self.save(path, tabs:)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate("tabs" => tabs.map { |tab| {"title" => tab.title, "cwd" => tab.terminal.cwd} }))
+    end
+
+    def self.load(path)
+      return [] unless File.file?(path)
+      JSON.parse(File.read(path)).fetch("tabs", [])
+    rescue JSON::ParserError
+      []
+    end
+  end
+end

data/lib/yildun/settings.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Yildun
+  class Settings
+    DEFAULTS = {
+      "font" => {"family" => "JetBrains Mono", "size" => 13, "ligatures" => true, "line_height" => 1.2},
+      "theme" => "tokyo-night",
+      "cursor" => {"shape" => "block", "blink" => true},
+      "background_opacity" => 1.0,
+      "scrollback_limit" => 10_000,
+      "shell_integration" => true,
+      "profiles" => {"default" => {"command" => [ENV.fetch("SHELL", "sh"), "-l"], "env" => {}}},
+      "default_profile" => "default",
+      "links" => {"file_line" => {"pattern" => "([\\w./-]+):(\\d+)", "action" => "open_editor"}},
+      "keymap" => {"cmd+t" => "tab.new", "cmd+d" => "pane.split_right", "cmd+f" => "search.open"}
+    }.freeze
+
+    attr_reader :values
+
+    def initialize(values = {})
+      @values = deep_merge(DEFAULTS, stringify_keys(values)).freeze
+    end
+
+    def [](key) = @values.fetch(key.to_s)
+    def fetch(key, default = nil) = @values.fetch(key.to_s, default)
+    def profile(name = @values.fetch("default_profile")) = @values.fetch("profiles").fetch(name.to_s)
+
+    def self.load(path = default_path)
+      return new unless File.file?(path)
+      new(parse_jsonc(File.read(path, encoding: "UTF-8")))
+    rescue JSON::ParserError, EncodingError => error
+      raise ArgumentError, "invalid settings: #{error.message}"
+    end
+
+    def self.default_path
+      root = ENV["XDG_CONFIG_HOME"] || File.join(Dir.home, ".config")
+      File.join(root, "yildun", "settings.jsonc")
+    end
+
+    def self.parse_jsonc(text)
+      chars = text.to_s.chars
+      output = +""
+      quote = false
+      escaped = false
+      line_comment = false
+      block_comment = false
+      index = 0
+      while index < chars.length
+        char = chars[index]
+        if line_comment
+          line_comment = false if char == "\n"
+          output << char if char == "\n"
+        elsif block_comment
+          if char == "*" && chars[index + 1] == "/"
+            block_comment = false
+            index += 1
+          else
+            output << "\n" if char == "\n"
+          end
+        elsif quote
+          output << char
+          if escaped
+            escaped = false
+          elsif char == "\\"
+            escaped = true
+          elsif char == '"'
+            quote = false
+          end
+        elsif char == '"'
+          quote = true
+          output << char
+        elsif char == "/" && chars[index + 1] == "/"
+          line_comment = true
+          index += 1
+        elsif char == "/" && chars[index + 1] == "*"
+          block_comment = true
+          index += 1
+        else
+          output << char
+        end
+        index += 1
+      end
+
+      JSON.parse(remove_trailing_commas(output))
+    end
+
+    def self.remove_trailing_commas(text)
+      chars = text.chars
+      output = +""
+      quote = false
+      escaped = false
+      chars.each_with_index do |char, index|
+        if quote
+          output << char
+          if escaped
+            escaped = false
+          elsif char == "\\"
+            escaped = true
+          elsif char == '"'
+            quote = false
+          end
+          next
+        end
+        if char == '"'
+          quote = true
+          output << char
+        elsif char == "," && chars[(index + 1)..].drop_while { |item| item.match?(/\s/) }.first.to_s.match?(/[}\]]/)
+          next
+        else
+          output << char
+        end
+      end
+      output
+    end
+
+    private
+
+    def stringify_keys(value)
+      case value
+      when Hash then value.to_h { |key, item| [key.to_s, stringify_keys(item)] }
+      when Array then value.map { |item| stringify_keys(item) }
+      else value
+      end
+    end
+
+    def deep_merge(left, right)
+      left.merge(right) do |_key, old, value|
+        old.is_a?(Hash) && value.is_a?(Hash) ? deep_merge(old, value) : value
+      end
+    end
+  end
+end

data/lib/yildun/tab.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Yildun
+  class Tab
+    attr_reader :title, :terminal
+
+    def initialize(terminal, title: nil)
+      @terminal, @title = terminal, (title || terminal.cwd)
+    end
+
+    def close = @terminal.close
+  end
+end

data/lib/yildun/terminal.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+tarazed_path = ENV["TARAZED_PATH"]
+tarazed_root = File.expand_path("..", __dir__)
+tarazed_path ? require(File.expand_path("lib/tarazed", File.expand_path(tarazed_path, tarazed_root))) : require("tarazed")
+
+module Yildun
+  class Terminal
+    attr_reader :session
+
+    def initialize(command:, env: {}, cwd: Dir.pwd, columns: 80, rows: 24, scrollback_limit: 10_000, session: nil)
+      @session = session || Tarazed::Session.new(command: command, env: env, cwd: cwd, columns: columns, rows: rows,
+        scrollback_limit: scrollback_limit)
+    end
+
+    def screen = @session.screen
+    def cwd = @session.cwd
+    def commands = @session.commands
+    def failed_commands = commands.select { |command| command.exit_status != 0 }
+    def input(bytes) = @session.input(bytes)
+    def paste(text) = @session.paste(text)
+    def key(name, **modifiers) = @session.key(name, **modifiers)
+    def mouse(**event) = @session.mouse(**event)
+    def pump(timeout: 0) = @session.pump(timeout: timeout)
+    def resize(columns:, rows:) = @session.resize(columns: columns, rows: rows)
+    def focus(active:) = @session.vt.focus(active: active)
+    def search(query, regex: false)
+      return screen.search(query, regex: regex) if screen.respond_to?(:search)
+
+      matcher = regex ? Regexp.new(query.to_s) : query.to_s
+      screen.lines.each_with_index.filter_map do |text, index|
+        match = regex ? matcher.match(text) : text.index(matcher)
+        next unless match
+
+        range = match.is_a?(MatchData) ? match.begin(0)...match.end(0) : match...(match + matcher.length)
+        {index: index, text: text, range: range}.freeze
+      end.freeze
+    rescue RegexpError => error
+      raise ArgumentError, "invalid search pattern: #{error.message}"
+    end
+
+    def previous_command
+      @command_index = [(@command_index || commands.length) - 1, 0].max
+      commands[@command_index]
+    end
+
+    def next_command
+      @command_index = [(@command_index || -1) + 1, commands.length - 1].min
+      commands[@command_index]
+    end
+
+    def last_command = commands.last
+
+    def command_output(command)
+      range = command&.output_range
+      return "" unless range
+
+      screen.selection([0, range.begin], [screen.columns, range.end], history: true)
+    end
+
+    alias copy_command_output command_output
+
+    def selection(start, finish, history: false) = screen.selection(start, finish, history: history)
+
+    def search_commands(query, regex: false)
+      matcher = regex ? Regexp.new(query.to_s) : query.to_s.downcase
+      commands.select do |command|
+        input = command.input.to_s
+        regex ? matcher.match?(input) : input.downcase.include?(matcher)
+      end
+    rescue RegexpError => error
+      raise ArgumentError, "invalid search pattern: #{error.message}"
+    end
+
+    def close = @session.close
+  end
+end

data/lib/yildun/theme.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Yildun
+  Theme = Data.define(:name, :background, :foreground, :cursor, :selection)
+  THEMES = {
+    "tokyo-night" => Theme.new("tokyo-night", "#1a1b26", "#c0caf5", "#c0caf5", "#33467c"),
+    "default" => Theme.new("default", "#111318", "#dddddd", "#ffffff", "#334455")
+  }.freeze
+
+  module_function
+
+  def theme(name) = THEMES.fetch(name.to_s, THEMES.fetch("default"))
+end

data/lib/yildun/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yildun
+  VERSION = "0.1.0"
+end

data/lib/yildun.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "yildun/version"
+require_relative "yildun/data_compat"
+require_relative "yildun/settings"
+require_relative "yildun/keymap"
+require_relative "yildun/theme"
+require_relative "yildun/profile"
+require_relative "yildun/search"
+require_relative "yildun/links"
+require_relative "yildun/terminal"
+require_relative "yildun/console"
+require_relative "yildun/tab"
+require_relative "yildun/pane"
+require_relative "yildun/session"
+require_relative "yildun/app"

data/sig/yildun.rbs

@@ -0,0 +1,86 @@
+module Yildun
+  VERSION: String
+  class Settings
+    attr_reader values: Hash[String, untyped]
+    def initialize: (?Hash[untyped, untyped] values) -> void
+    def []: (String key) -> untyped
+    def fetch: (String key, ?untyped default) -> untyped
+    def profile: (?String name) -> Hash[String, untyped]
+    def self.load: (?String path) -> Settings
+    def self.default_path: () -> String
+    def self.parse_jsonc: (String text) -> Hash[untyped, untyped]
+  end
+  class Keymap
+    def initialize: (?Hash[untyped, untyped] bindings) -> void
+    def command: (String key) -> String?
+    def include?: (String key) -> bool
+  end
+  class Terminal
+    attr_reader session: untyped
+    def initialize: (command: String | Array[String], ?env: Hash[String, String], ?cwd: String, ?columns: Integer, ?rows: Integer, ?scrollback_limit: Integer, ?session: untyped) -> void
+    def screen: () -> untyped
+    def cwd: () -> String
+    def commands: () -> Array[untyped]
+    def failed_commands: () -> Array[untyped]
+    def input: (String bytes) -> untyped
+    def paste: (String text) -> untyped
+    def key: (String name, **bool modifiers) -> untyped
+    def mouse: (**untyped event) -> untyped
+    def pump: (?timeout: Numeric) -> bool
+    def resize: (columns: Integer, rows: Integer) -> untyped
+    def focus: (active: bool) -> String
+    def search: (String query, ?regex: bool) -> Array[Hash[Symbol, untyped]]
+    def previous_command: () -> untyped
+    def next_command: () -> untyped
+    def last_command: () -> untyped
+    def command_output: (untyped command) -> String
+    alias copy_command_output command_output
+    def selection: (Array[Integer] start, Array[Integer] finish, ?history: bool) -> String
+    def search_commands: (String query, ?regex: bool) -> Array[untyped]
+    def close: () -> untyped
+  end
+
+  class Console
+    def initialize: (untyped terminal, ?input: untyped, ?output: untyped) -> void
+    def run: () -> untyped
+    def render: () -> untyped
+  end
+
+  class Pane
+    attr_reader children: Array[untyped]
+    attr_reader orientation: Symbol
+    def initialize: (?untyped tab, ?orientation: Symbol) -> void
+    def leaf?: () -> bool
+    def split: (untyped tab, ?orientation: Symbol) -> Pane
+  end
+
+  class Search
+    def initialize: (untyped terminal) -> void
+    def call: (String query, ?regex: bool) -> untyped
+  end
+
+  module Links
+    def self.at: (untyped screen, Integer row, Integer column, ?cwd: String) -> Hash[Symbol, untyped]?
+    def self.open: (String url, ?opener: ^(String) -> untyped) -> untyped
+  end
+
+  class SessionState
+    def self.save: (String path, tabs: Array[untyped]) -> untyped
+    def self.load: (String path) -> Array[Hash[String, untyped]]
+  end
+  class Tab
+    attr_reader title: String
+    attr_reader terminal: Terminal
+  end
+  class App
+    attr_reader settings: Settings
+    attr_reader tabs: Array[Tab]
+    attr_reader active_index: Integer
+    def initialize: (?settings: Settings, ?profile: untyped, ?columns: Integer, ?rows: Integer) -> void
+    def active_tab: () -> Tab
+    def active_terminal: () -> Terminal
+    def open_tab: (?profile: untyped, ?cwd: String, ?columns: Integer, ?rows: Integer) -> Tab
+    def open_tab_here: (?profile: untyped, ?columns: Integer, ?rows: Integer) -> Tab
+    def close_active: () -> untyped
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: yildun
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tarazed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: A terminal application shell with tabs, profiles, search, links, and
+  Tarazed-backed sessions.
+email:
+- t.yudai92@gmail.com
+executables:
+- yildun
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/adr/001-cell-rendering.md
+- docs/adr/002-shell-integration.md
+- exe/yildun
+- lib/yildun.rb
+- lib/yildun/app.rb
+- lib/yildun/console.rb
+- lib/yildun/data_compat.rb
+- lib/yildun/keymap.rb
+- lib/yildun/links.rb
+- lib/yildun/pane.rb
+- lib/yildun/profile.rb
+- lib/yildun/search.rb
+- lib/yildun/session.rb
+- lib/yildun/settings.rb
+- lib/yildun/tab.rb
+- lib/yildun/terminal.rb
+- lib/yildun/theme.rb
+- lib/yildun/version.rb
+- sig/yildun.rbs
+homepage: https://github.com/noxdea/yildun
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/noxdea/yildun
+  changelog_uri: https://github.com/noxdea/yildun/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A pure Ruby terminal application built on Tarazed
+test_files: []