ligarb 0.4.0 → 0.5.0

data/lib/ligarb/cli.rb

@@ -17,15 +17,26 @@ module Ligarb
         Builder.new(config_path).build
       when "init"
         Initializer.new(args.first).run
+      when "serve"
+        config_paths = args.reject { |a| a.start_with?("--") }
+        config_paths = ["book.yml"] if config_paths.empty?
+        port_idx = args.index("--port")
+        port = port_idx ? args[port_idx + 1].to_i : 3000
+        require_relative "server"
+        Server.new(config_paths, port: port).start
       when "write"
-        if args.delete("--init")
-          require_relative "writer"
-          Writer.init_brief(args.first)
-        else
-          brief_path = args.reject { |a| a.start_with?("--") }.first || "brief.yml"
-          no_build = args.include?("--no-build")
-          require_relative "writer"
-          Writer.new(brief_path, no_build: no_build).run
+        require_relative "writer"
+        begin
+          if args.delete("--init")
+            Writer.init_brief(args.first)
+          else
+            brief_path = args.reject { |a| a.start_with?("--") }.first || "brief.yml"
+            no_build = args.include?("--no-build")
+            Writer.new(brief_path, no_build: no_build).run
+          end
+        rescue Writer::WriterError => e
+          $stderr.puts "Error: #{e.message}"
+          exit 1
         end
       when "--help", "-h", nil
         print_usage
@@ -47,6 +58,7 @@ module Ligarb
         Usage:
           ligarb init [DIRECTORY]  Create a new book project
           ligarb build [CONFIG]    Build the HTML book (default CONFIG: book.yml)
+          ligarb serve [CONFIG]   Serve the book with live reload and review UI
           ligarb write [BRIEF]         Generate a book with AI from brief.yml
           ligarb write --init [DIR]    Create DIR/brief.yml template
           ligarb help              Show detailed specification (for AI integration)
@@ -109,6 +121,31 @@ module Ligarb
         ligarb build [CONFIG]   Build the HTML book.
                                 CONFIG defaults to 'book.yml' in the current directory.
 
+        ligarb serve [CONFIG...]
+                                Start a local web server with live reload and review UI.
+                                CONFIG defaults to 'book.yml' in the current directory.
+                                Multiple CONFIG paths can be given to serve multiple books.
+                                Options:
+                                  --port PORT  Server port (default: 3000)
+                                Single book mode (1 CONFIG):
+                                - Serves the built HTML book at http://localhost:PORT
+                                Multi-book mode (2+ CONFIGs):
+                                - Top page (/) shows a book index with links
+                                - Each book is served at /<directory-name>/
+                                - "Write a new book" button on the index page to generate
+                                  a new book via AI (posts a brief, runs Writer in background)
+                                - Example: ligarb serve */book.yml
+                                Features:
+                                - Injects a reload button that pulses when build output changes
+                                - Injects a review UI for commenting on book text
+                                - Review comments are saved to .ligarb/reviews/*.json
+                                  (in each book's directory)
+                                - If 'claude' CLI is installed, comments are sent to Claude
+                                  for review suggestions, and approved changes are applied
+                                  to the source Markdown files and the book is rebuilt
+                                - Review patches can span multiple chapters and the
+                                  bibliography file (Claude reads book.yml to find all files)
+
         ligarb help             Show this detailed specification.
 
         ligarb --help           Show short usage summary.
@@ -344,6 +381,67 @@ module Ligarb
 
         Clicking an index entry navigates to the exact location in the chapter.
 
+        == Bibliography ==
+
+        Cite references in the text using Markdown link syntax with #cite:
+
+            [Ruby](#cite:matz1995)       Cite by key; rendered as Ruby[Matsumoto, 1995]
+
+        Define a bibliography data file in book.yml:
+
+            bibliography: references.yml   # YAML format
+            bibliography: references.bib   # BibTeX format
+
+        The format is auto-detected by file extension (.bib = BibTeX, otherwise YAML).
+
+        YAML format maps keys to reference data:
+
+            matz1995:
+              author: "Yukihiro Matsumoto"
+              title: "The Ruby Programming Language"
+              year: 1995
+              url: "https://www.ruby-lang.org"
+              publisher: "O'Reilly"
+              doi: "10.1234/example"
+
+        BibTeX format (.bib) is also supported:
+
+            @book{matz1995,
+              author = {Yukihiro Matsumoto},
+              title = {The Ruby Programming Language},
+              year = {1995},
+              publisher = {O'Reilly},
+              url = {https://www.ruby-lang.org}
+            }
+
+        BibTeX notes:
+        - Entry types (@book, @article, etc.) are preserved for formatting
+        - Field values can use {braces} or "quotes"
+        - Nested braces are supported one level deep ({The {Ruby} Language})
+        - Lines starting with % are comments
+
+        Supported fields (YAML and BibTeX):
+        author, title, year, url, publisher, journal, booktitle, volume,
+        number, pages, edition, doi, editor, note.
+
+        The bibliography section formats entries by type:
+        - book:          Author. Title. Edition. Publisher, Year.
+        - article:       Author. "Title". Journal, Volume(Number), Pages, Year.
+        - inproceedings: Author. "Title". In Booktitle, Pages, Year.
+        - other/YAML:    Author. Title. Publisher/Journal, Volume, Pages, Year.
+
+        If url is present, the title becomes a link. If doi is present, a DOI link
+        is appended.
+
+        The citation is rendered as a superscript [author, year] link that navigates
+        to the "Bibliography" section at the end of the book. Hovering the link shows
+        the full reference. The bibliography section lists all cited entries sorted by
+        author and year.
+
+        A warning is printed and the citation is rendered as [key?] (highlighted in
+        red) if a cite key is not found in the bibliography file.
+        If no bibliography file is configured, cite markers are left as-is.
+
         == Custom CSS ==
 
         Add a 'style' field to book.yml to inject custom CSS:

data/lib/ligarb/config.rb

@@ -14,7 +14,7 @@ module Ligarb
 
     attr_reader :title, :author, :language, :output_dir, :base_dir,
                 :chapter_numbers, :structure, :style, :repository,
-                :ai_generated, :footer
+                :ai_generated, :footer, :bibliography, :sources
 
     def initialize(path)
       @base_dir = File.dirname(File.expand_path(path))
@@ -31,6 +31,8 @@ module Ligarb
       @repository      = data.fetch("repository", nil)
       @ai_generated    = data.fetch("ai_generated", false)
       @footer          = data.fetch("footer", nil)
+      @bibliography    = data.fetch("bibliography", nil)
+      @sources         = parse_sources(data.fetch("sources", []))
       @structure       = parse_structure(data["chapters"])
     end
 
@@ -42,6 +44,10 @@ module Ligarb
       @style ? File.join(@base_dir, @style) : nil
     end
 
+    def bibliography_path
+      @bibliography ? File.join(@base_dir, @bibliography) : nil
+    end
+
     def appendix_label
       @language == "ja" ? "付録" : "Appendix"
     end
@@ -69,6 +75,24 @@ module Ligarb
 
     private
 
+    Source = Struct.new(:path, :label, keyword_init: true)
+
+    def parse_sources(entries)
+      return [] unless entries.is_a?(Array)
+
+      entries.map do |entry|
+        case entry
+        when String
+          Source.new(path: File.join(@base_dir, entry), label: File.basename(entry))
+        when Hash
+          path = entry["path"] or abort "Error: source entry missing 'path'"
+          Source.new(path: File.join(@base_dir, path), label: entry.fetch("label", File.basename(path)))
+        else
+          abort "Error: invalid source entry: #{entry.inspect}"
+        end
+      end
+    end
+
     def parse_structure(entries)
       entries.map do |entry|
         case entry

data/lib/ligarb/inotify.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Thin Fiddle wrapper for Linux inotify(7).
+# Non-Linux platforms will get LoadError from dlsym lookup.
+
+require "fiddle"
+
+module Ligarb
+  module Inotify
+    LIBC = Fiddle.dlopen(nil)
+
+    InotifyInit1 = Fiddle::Function.new(
+      LIBC["inotify_init1"],
+      [Fiddle::TYPE_INT],
+      Fiddle::TYPE_INT
+    )
+
+    InotifyAddWatch = Fiddle::Function.new(
+      LIBC["inotify_add_watch"],
+      [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_UINT32_T],
+      Fiddle::TYPE_INT
+    )
+
+    InotifyRmWatch = Fiddle::Function.new(
+      LIBC["inotify_rm_watch"],
+      [Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+      Fiddle::TYPE_INT
+    )
+
+    # inotify event masks
+    IN_CLOSE_WRITE = 0x00000008
+    IN_CLOEXEC     = 0x00080000  # O_CLOEXEC on x86_64
+
+    # struct inotify_event fixed part: int wd, uint32 mask, uint32 cookie, uint32 len
+    EVENT_HEADER_SIZE = 16
+
+    # Watch a file for writes. Yields each time the file is written and closed.
+    # Blocks the calling thread. Caller should wrap in Thread.new.
+    def self.watch_file(path, &block)
+      fd = InotifyInit1.call(IN_CLOEXEC)
+      raise SystemCallError.new("inotify_init1", Fiddle.last_error) if fd < 0
+
+      io = IO.for_fd(fd, autoclose: true)
+      wd = add_watch(fd, path)
+
+      loop do
+        # IO.select releases GVL while waiting
+        IO.select([io])
+        buf = io.read_nonblock(4096, exception: false)
+        next if buf == :wait_readable || buf.nil?
+
+        # Parse events — may contain multiple events
+        offset = 0
+        while offset + EVENT_HEADER_SIZE <= buf.bytesize
+          _wd, mask, _cookie, name_len = buf.byteslice(offset, EVENT_HEADER_SIZE).unpack("iIII")
+          offset += EVENT_HEADER_SIZE + name_len
+
+          if mask & IN_CLOSE_WRITE != 0
+            block.call
+          end
+        end
+      rescue IOError, Errno::EBADF
+        break
+      end
+    ensure
+      io&.close rescue nil
+    end
+
+    def self.add_watch(fd, path)
+      wd = InotifyAddWatch.call(fd, path, IN_CLOSE_WRITE)
+      raise SystemCallError.new("inotify_add_watch: #{path}", Fiddle.last_error) if wd < 0
+      wd
+    end
+  end
+end

data/lib/ligarb/review_store.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "fileutils"
+
+module Ligarb
+  class ReviewStore
+    def initialize(base_dir)
+      @dir = File.join(base_dir, ".ligarb", "reviews")
+      FileUtils.mkdir_p(@dir)
+    end
+
+    def list
+      Dir.glob(File.join(@dir, "*.json")).map { |f| read_json(f) }
+        .compact
+        .sort_by { |r| r["created_at"] }
+        .map { |r| summary(r) }
+    end
+
+    def get(id)
+      path = file_path(id)
+      return nil unless File.exist?(path)
+      read_json(path)
+    end
+
+    def create(context:, message:)
+      id = SecureRandom.uuid
+      now = Time.now.utc.iso8601
+
+      review = {
+        "id" => id,
+        "status" => "open",
+        "created_at" => now,
+        "context" => context,
+        "messages" => [
+          { "role" => "user", "content" => message, "timestamp" => now }
+        ]
+      }
+
+      write_json(id, review)
+      review
+    end
+
+    def add_message(id, role:, content:)
+      review = get(id)
+      return nil unless review
+
+      review["messages"] << {
+        "role" => role,
+        "content" => content,
+        "timestamp" => Time.now.utc.iso8601
+      }
+
+      write_json(id, review)
+      review
+    end
+
+    def update_context_files(id, files)
+      review = get(id)
+      return nil unless review
+
+      existing = review.dig("context", "uploaded_files") || []
+      review["context"]["uploaded_files"] = existing + files
+      write_json(id, review)
+      review
+    end
+
+    def update_status(id, status)
+      review = get(id)
+      return nil unless review
+
+      review["status"] = status
+      write_json(id, review)
+      review
+    end
+
+    def delete(id)
+      path = file_path(id)
+      return false unless File.exist?(path)
+      File.delete(path)
+      true
+    end
+
+    private
+
+    def file_path(id)
+      File.join(@dir, "#{id}.json")
+    end
+
+    def read_json(path)
+      JSON.parse(File.read(path))
+    rescue JSON::ParserError
+      nil
+    end
+
+    def write_json(id, data)
+      File.write(file_path(id), JSON.pretty_generate(data))
+    end
+
+    def summary(review)
+      {
+        "id" => review["id"],
+        "status" => review["status"],
+        "created_at" => review["created_at"],
+        "context" => review["context"],
+        "message_count" => review["messages"].size,
+        "last_message" => review["messages"].last
+      }
+    end
+  end
+end