mkd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cdff350d72636cbe26d157b998b0fcdd3c492085ac4a8d41a349b4ee7ee963c5
+  data.tar.gz: 8dc3585e64bb312649648d6d45028fb6d92051214f2e69144b0da9f086285be0
+SHA512:
+  metadata.gz: d33f2419baa2873e7585b1cf398f09026e1613c1d945a6b453983fd2d47f45fabccb12006c3dad1dfe906aba7c363fcb973c50e9c64c64e4439cd96ba8275141
+  data.tar.gz: 5c138f78eab2f4621147716b3bb7c6aab31e42e9c96809f6ff2733128de83a4a001026a33e96a35228632b6142846e18424ba6f9674e6f9f3d441e94d0c2e830

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Akira Matsuda
+
+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,93 @@
+# mkd
+
+A terminal Markdown viewer. Renders Markdown with ANSI escape codes and the Kitty graphics/text sizing protocol.
+
+## Installation
+
+```bash
+gem install mkd
+```
+
+Or add to your Gemfile:
+
+```bash
+bundle add mkd
+```
+
+## Usage
+
+```bash
+mkd README.md
+```
+
+Or pipe from stdin:
+
+```bash
+cat README.md | mkd
+```
+
+From Ruby:
+
+```ruby
+require 'mkd'
+print Mkd.render(markdown_string)
+```
+
+## Features
+
+### Inline formatting
+
+- **Bold**, *italic*, ***bold italic***, ~~strikethrough~~, `inline code`
+- [Hyperlinks](https://example.com) via OSC 8 terminal sequences
+- :emoji: shortcodes (GitHub-style, powered by gemoji)
+
+### Headings
+
+- H1 and H2 use scaled text via the text sizing protocol (OSC 66) when the terminal supports it, falling back to bold text otherwise
+- Terminal support is auto-detected at runtime by probing cursor position
+- H3 through H6 use bold, underline, and dim ANSI styles
+
+### Code blocks
+
+Syntax-highlighted fenced code blocks via Rouge:
+
+```ruby
+puts "hello, world"
+```
+
+### Lists
+
+- Unordered lists with bullet characters
+- Ordered (numbered) lists
+- Nested lists with increasing indentation
+- GFM task lists:
+  - [ ] unchecked
+  - [x] checked
+
+### Tables
+
+Rendered with box-drawing characters:
+
+| Feature  | Status |
+|----------|--------|
+| Tables   | :white_check_mark: |
+| Alignment| :white_check_mark: |
+
+### Other
+
+- Block quotes with vertical bar
+- Horizontal rules
+- Images displayed inline via the Kitty graphics protocol (PNG, SVG)
+- Clickable image links
+
+## Screenshot
+![Screenshot](screenshot.png)
+
+## Requirements
+
+- A terminal with ANSI escape code support
+- [Kitty](https://sw.kovidgoyal.net/kitty/) (or compatible terminal, like [Echoes](https://github.com/amatsuda/echoes)) for image display and scaled headings (auto-detected; works without these in degraded mode)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/exe/mkd

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'mkd'
+
+input = ARGF.read
+print Mkd.render(input)

data/lib/mkd/renderer.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'open-uri'
+require 'redcarpet'
+require 'rouge'
+
+module Mkd
+  class Renderer < Redcarpet::Render::Base
+    def initialize
+      super
+      @ordered_counter = 0
+      @text_sizing = detect_text_sizing
+    end
+
+    # Inline callbacks
+
+    def normal_text(text)
+      text
+    end
+
+    def emphasis(text)
+      "\e[3m#{text}\e[23m"
+    end
+
+    def double_emphasis(text)
+      "\e[1m#{text}\e[22m"
+    end
+
+    def triple_emphasis(text)
+      "\e[1m\e[3m#{text}\e[23m\e[22m"
+    end
+
+    def strikethrough(text)
+      "\e[9m#{text}\e[29m"
+    end
+
+    def codespan(code)
+      "\e[7m#{code}\e[27m"
+    end
+
+    def linebreak
+      "\n"
+    end
+
+    def link(link, _title, content)
+      if content.include?("\e_G") && @last_image_dimensions
+        apc = content.chomp.sub("\e_Ga=T,", "\e_Ga=T,C=1,")
+        cols, rows = image_cells(*@last_image_dimensions)
+        lines = Array.new(rows) { ' ' * cols }.join("\n")
+        "#{apc}\e]8;;#{link}\a#{lines}\e]8;;\a\n"
+      elsif content.include?("\e_G")
+        "#{content.chomp}\e]8;;#{link}\a\u2197\e]8;;\a\n"
+      else
+        "\e]8;;#{link}\a#{content}\e]8;;\a"
+      end
+    end
+
+    def autolink(link, _link_type)
+      "\e]8;;#{link}\a\e[4m#{link}\e[24m\e]8;;\a"
+    end
+
+    def image(link, _title, alt_text)
+      @last_image_dimensions = nil
+      if link.match?(%r{\Ahttps?://})
+        data = URI.parse(link).read
+        data = rsvg_convert(data) if link.end_with?('.svg')
+        @last_image_dimensions = png_dimensions(data)
+        "#{kitty_image_data(data)}\n"
+      else
+        path = File.expand_path(link)
+        if File.file?(path)
+          if path.end_with?('.svg')
+            data = rsvg_convert(File.binread(path))
+            @last_image_dimensions = png_dimensions(data)
+            "#{kitty_image_data(data)}\n"
+          else
+            @last_image_dimensions = png_dimensions(File.binread(path, 24))
+            "#{kitty_image(path)}\n"
+          end
+        else
+          "\e[2m[image: #{alt_text}]\e[22m"
+        end
+      end
+    rescue
+      @last_image_dimensions = nil
+      "\e[2m[image: #{alt_text}]\e[22m"
+    end
+
+    # Block callbacks
+
+    def paragraph(text)
+      "#{text}\n\n"
+    end
+
+    def header(text, header_level)
+      case header_level
+      when 1
+        before, after, clean = extract_heading_parts(text)
+        sized = @text_sizing ? kitty_sized(clean, scale: 3) : clean
+        "#{before}\e[1m#{sized}\n\n\n\e[22m#{after}"
+      when 2
+        before, after, clean = extract_heading_parts(text)
+        sized = @text_sizing ? kitty_sized(clean, scale: 2) : clean
+        "#{before}\e[1m#{sized}\n\n\e[22m#{after}"
+      when 3
+        "\e[1m#{text}\e[22m\n\n"
+      when 4
+        "\e[1m\e[4m#{text}\e[24m\e[22m\n\n"
+      when 5
+        "\e[1m\e[2m#{text}\e[22m\e[22m\n\n"
+      when 6
+        "\e[2m#{text}\e[22m\n\n"
+      end
+    end
+
+    def block_code(code, language)
+      lexer = Rouge::Lexer.find(language) || Rouge::Lexers::PlainText.new
+      formatter = Rouge::Formatters::Terminal256.new
+      highlighted = formatter.format(lexer.lex(code))
+      indented = highlighted.lines.map { |line| "    #{line}" }.join
+      "#{indented}\n"
+    end
+
+    def block_quote(content)
+      content.lines.map { |line| "\e[2m\u2502\e[22m #{line}" }.join
+    end
+
+    def table(header, body)
+      rows = parse_table_rows(header + body)
+      num_cols = rows.first&.size || 0
+      alignments = @table_alignments&.first(num_cols) || []
+      @table_alignments = nil
+
+      col_widths = Array.new(num_cols, 0)
+      rows.each do |row|
+        row.each_with_index do |cell, i|
+          w = visible_length(cell)
+          col_widths[i] = w if w > col_widths[i]
+        end
+      end
+
+      header_rows = parse_table_rows(header)
+      body_rows = parse_table_rows(body)
+
+      result = +''
+      result << table_border(col_widths, '┌', '┬', '┐')
+      header_rows.each { |row| result << table_data_row(row, col_widths, alignments, bold: true) }
+      result << table_border(col_widths, '├', '┼', '┤')
+      body_rows.each { |row| result << table_data_row(row, col_widths, alignments, bold: false) }
+      result << table_border(col_widths, '└', '┴', '┘')
+      "#{result}\n"
+    end
+
+    def table_row(content)
+      "#{content}\x01"
+    end
+
+    def table_cell(content, alignment, _header)
+      @table_alignments ||= []
+      @table_alignments << alignment
+      "#{content}\x00"
+    end
+
+    def list(content, _list_type)
+      @ordered_counter = 0
+      content.lines.map { |l| "  #{l}" }.join + "\n"
+    end
+
+    def list_item(text, list_type)
+      first_line, rest = text.split("\n", 2)
+      first_line = first_line.strip
+
+      prefix = if list_type == :ordered
+        @ordered_counter += 1
+        "#{@ordered_counter}. "
+      elsif first_line.start_with?('[ ] ')
+        first_line = first_line.delete_prefix('[ ] ')
+        "\u2610 "
+      elsif first_line.match?(/\A\[[xX]\] /)
+        first_line = first_line.sub(/\A\[[xX]\] /, '')
+        "\u2611 "
+      else
+        "\u2022 "
+      end
+
+      result = "#{prefix}#{first_line}\n"
+      if rest
+        rest = rest.gsub(/\n+\z/, "\n")
+        result << rest unless rest.strip.empty?
+      end
+      result
+    end
+
+    def hrule
+      "#{'─' * 40}\n\n"
+    end
+
+    def doc_footer
+      "\e[0m"
+    end
+
+    private
+
+    def extract_heading_parts(text)
+      image_re = /((?:\e_.*?\e\\)+(?:\e\]8;;[^\a]*\a.*?\e\]8;;\a)?\n?)/m
+      parts = text.split(image_re).reject(&:empty?)
+      before = +''
+      after = +''
+      text_parts = []
+      found_text = false
+      parts.each do |part|
+        if part.match?(/\e_/)
+          found_text ? after << part : before << part
+        else
+          stripped = part.strip
+          next if stripped.empty?
+          found_text = true
+          text_parts << stripped
+        end
+      end
+      [before, after, text_parts.join(' ')]
+    end
+
+    def parse_table_rows(str)
+      str.split("\x01").filter_map do |row_str|
+        cells = row_str.split("\x00")
+        cells.pop if cells.last&.empty?
+        cells unless cells.empty?
+      end
+    end
+
+    def visible_length(str)
+      stripped = str.gsub(/\e\]8;;[^\a]*\a/, '').gsub(/\e\[[0-9;]*m/, '').gsub(/\e_G[^\e]*\e\\/, '')
+      stripped.each_char.sum { |c| wide_char?(c) ? 2 : 1 }
+    end
+
+    def wide_char?(c)
+      return true if /\p{Emoji_Presentation}/.match?(c)
+
+      cp = c.ord
+      (cp >= 0x1100 && cp <= 0x115F) ||
+        (cp >= 0x2E80 && cp <= 0x9FFF) ||
+        (cp >= 0xAC00 && cp <= 0xD7A3) ||
+        (cp >= 0xF900 && cp <= 0xFAFF) ||
+        (cp >= 0xFE10 && cp <= 0xFE19) ||
+        (cp >= 0xFE30 && cp <= 0xFE6F) ||
+        (cp >= 0xFF01 && cp <= 0xFF60) ||
+        (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+        (cp >= 0x20000 && cp <= 0x2FFFD) ||
+        (cp >= 0x30000 && cp <= 0x3FFFD)
+    end
+
+    def table_border(col_widths, left, mid, right)
+      "#{left}#{col_widths.map { |w| '─' * (w + 2) }.join(mid)}#{right}\n"
+    end
+
+    def table_data_row(row, col_widths, alignments, bold:)
+      cells = col_widths.each_with_index.map do |w, i|
+        content = row[i] || ''
+        padded = align_cell(content, w, alignments[i])
+        bold ? " \e[1m#{padded}\e[22m " : " #{padded} "
+      end
+      "│#{cells.join('│')}│\n"
+    end
+
+    def align_cell(content, width, alignment)
+      padding = width - visible_length(content)
+      return content if padding <= 0
+
+      case alignment
+      when :right
+        "#{' ' * padding}#{content}"
+      when :center
+        left = padding / 2
+        right = padding - left
+        "#{' ' * left}#{content}#{' ' * right}"
+      else
+        "#{content}#{' ' * padding}"
+      end
+    end
+
+    def detect_text_sizing
+      con = IO.console
+      return false unless con
+
+      con.raw do |c|
+        pos1 = query_cursor_position(c)
+        return false unless pos1
+
+        c.write("\e]66;s=2;X\a")
+
+        pos2 = query_cursor_position(c)
+        return false unless pos2
+
+        supported = pos1 != pos2
+        c.write("\e[#{pos1[0]};#{pos1[1]}H\e[J") if supported
+        supported
+      end
+    rescue
+      false
+    end
+
+    def query_cursor_position(io)
+      io.write("\e[6n")
+      buf = +''
+      while IO.select([io], nil, nil, 0.1)
+        buf << io.read_nonblock(64)
+        return [$1.to_i, $2.to_i] if buf =~ /\e\[(\d+);(\d+)R/
+      end
+      nil
+    end
+
+    def kitty_sized(text, scale:)
+      "\e]66;s=#{scale};#{text}\a"
+    end
+
+    def kitty_image(path)
+      encoded_path = [path].pack('m0')
+      "\e_Ga=T,f=100,t=f;#{encoded_path}\e\\"
+    end
+
+    def rsvg_convert(svg_data)
+      IO.popen(['rsvg-convert', '--format=png'], 'r+b') do |io|
+        io.write(svg_data)
+        io.close_write
+        io.read
+      end
+    end
+
+    def kitty_image_data(data)
+      encoded = [data].pack('m0')
+      chunks = encoded.scan(/.{1,4096}/)
+      if chunks.size == 1
+        "\e_Ga=T,f=100,t=d;#{chunks[0]}\e\\"
+      else
+        result = +"\e_Ga=T,f=100,t=d,m=1;#{chunks[0]}\e\\"
+        chunks[1...-1].each { |chunk| result << "\e_Gm=1;#{chunk}\e\\" }
+        result << "\e_Gm=0;#{chunks[-1]}\e\\"
+        result
+      end
+    end
+
+    def png_dimensions(data)
+      return unless data.byteslice(0, 8) == "\x89PNG\r\n\x1a\n".b
+
+      [data.byteslice(16, 4).unpack1('N'), data.byteslice(20, 4).unpack1('N')]
+    end
+
+    def cell_size
+      buf = [0].pack('S!') * 4
+      fd = IO.sysopen('/dev/tty', IO::RDWR)
+      io = IO.new(fd)
+      io.ioctl(0x40087468, buf) # TIOCGWINSZ
+      io.close
+      rows, cols, xpixel, ypixel = buf.unpack('S!4')
+      cw = cols > 0 && xpixel > 0 ? xpixel / cols : 8
+      ch = rows > 0 && ypixel > 0 ? ypixel / rows : 16
+      [cw, ch]
+    rescue
+      [8, 16]
+    end
+
+    def image_cells(width, height)
+      cw, ch = cell_size
+      [(width.to_f / cw).ceil, (height.to_f / ch).ceil]
+    end
+  end
+end

data/lib/mkd/version.rb

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

data/lib/mkd.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'emoji'
+require_relative 'mkd/version'
+require_relative 'mkd/renderer'
+
+module Mkd
+  def self.render(markdown_text)
+    markdown_text = markdown_text.gsub(/:(\w+):/) { Emoji.find_by_alias($1)&.raw || $& }
+    renderer = Renderer.new
+    markdown = Redcarpet::Markdown.new(renderer, fenced_code_blocks: true, strikethrough: true, no_intra_emphasis: true, autolink: true, tables: true, superscript: true, lax_spacing: true)
+    markdown.render(markdown_text)
+  end
+end

data/sig/mkd.rbs

@@ -0,0 +1,4 @@
+module Mkd
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: mkd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Akira Matsuda
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gemoji
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Renders Markdown in the terminal using ANSI escape codes and the kitty
+  text sizing protocol for headings.
+email:
+- ronnie@dio.jp
+executables:
+- mkd
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/mkd
+- lib/mkd.rb
+- lib/mkd/renderer.rb
+- lib/mkd/version.rb
+- screenshot.png
+- sig/mkd.rbs
+homepage: https://github.com/amatsuda/mkd
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/amatsuda/mkd
+  homepage_uri: https://github.com/amatsuda/mkd
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.1.0.dev
+specification_version: 4
+summary: Terminal Markdown viewer
+test_files: []