ligarb 0.3.0 → 0.5.0

data/lib/ligarb/cli.rb

@@ -17,6 +17,27 @@ 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"
+        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
       when "help"
@@ -37,6 +58,9 @@ 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)
           ligarb version          Show version number
 
@@ -53,6 +77,8 @@ module Ligarb
           chapter_numbers  (optional) Show chapter/section numbers (default: true)
           style            (optional) Custom CSS file path (default: none)
           repository       (optional) GitHub repository URL for "Edit on GitHub" links
+          ai_generated     (optional) Mark as AI-generated (badge + meta tags, default: false)
+          footer           (optional) Custom text at bottom of each chapter
 
         Example:
           ligarb build
@@ -60,8 +86,8 @@ module Ligarb
       USAGE
     end
 
-    def print_spec
-      puts <<~SPEC
+    def spec_text
+      <<~SPEC
         ligarb - Generate a single-page HTML book from Markdown files
 
         Version: #{VERSION}
@@ -95,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.
@@ -117,6 +168,14 @@ module Ligarb
                          When set, each chapter shows a "View on GitHub" link.
                          The link points to {repository}/blob/HEAD/{path-from-git-root}.
                          The chapter path is resolved relative to the Git repository root.
+        ai_generated:    (optional) Mark the book as AI-generated content. Default: false.
+                         When true: adds an "AI Generated" badge in the sidebar header,
+                         adds a default disclaimer footer to each chapter, and adds
+                         noindex/noai meta tags to prevent search indexing and AI training.
+                         The footer text can be overridden with the 'footer' field.
+        footer:          (optional) Custom text displayed at the bottom of each chapter.
+                         Overrides the default ai_generated disclaimer if both are set.
+                         Useful for copyright notices, disclaimers, or other per-chapter text.
         chapters:        (required) Book structure. An array that can contain:
                          - A cover: a centered title/landing page
                          - A string: a chapter Markdown file path (relative to book.yml)
@@ -262,6 +321,17 @@ module Ligarb
             E = mc^2
             ```
 
+        Inline math uses $...$ syntax within text:
+
+            The equation $E = mc^2$ is well-known.
+
+        Rules for inline math:
+        - $$ is not matched (use ```math for display math)
+        - $ followed by a space is not matched (e.g. $10)
+        - $ preceded by a space is not matched
+        - Content inside <code> and <pre> is not affected
+        - The content is rendered with KaTeX (displayMode: false)
+
         == Images ==
 
         Place image files in the 'images/' directory next to book.yml.
@@ -311,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:
@@ -405,8 +536,43 @@ module Ligarb
 
         Each chapter displays Previous and Next navigation links at the bottom.
         These follow the flat chapter order (including across parts and appendix).
-        Part title pages do not show navigation.
+        Cover pages do not show navigation.
+
+        == Write Command ==
+
+        ligarb write [BRIEF]        Generate a complete book using AI (Claude).
+                                    BRIEF defaults to 'brief.yml' in the current directory.
+                                    Reads the brief, sends a prompt to Claude, and builds
+                                    the generated book. Files are created in the same
+                                    directory as brief.yml.
+
+        ligarb write --init [DIR]   Create a brief.yml template.
+                                    If DIR is given, creates DIR/brief.yml (mkdir as needed).
+                                    If omitted, creates brief.yml in the current directory.
+
+        ligarb write --no-build     Generate files only, skip the build step.
+
+        brief.yml fields:
+
+        title:           (required) The book title.
+        language:        (optional) Language. Default: "ja".
+        audience:        (optional) Target audience (used in the prompt).
+        notes:           (optional) Additional instructions for Claude (free text).
+        author:          (optional) Passed through to book.yml.
+        output_dir:      (optional) Passed through to book.yml.
+        chapter_numbers: (optional) Passed through to book.yml.
+        style:           (optional) Passed through to book.yml.
+        repository:      (optional) Passed through to book.yml.
+
+        The book is generated in the directory containing brief.yml.
+        Example: 'ligarb write ruby_book/brief.yml' creates files in ruby_book/.
+
+        Requires the 'claude' CLI to be installed.
       SPEC
     end
+
+    def print_spec
+      puts spec_text
+    end
   end
 end

data/lib/ligarb/config.rb

@@ -13,7 +13,8 @@ module Ligarb
     # children: array of StructEntry (for :part and :appendix_group)
 
     attr_reader :title, :author, :language, :output_dir, :base_dir,
-                :chapter_numbers, :structure, :style, :repository
+                :chapter_numbers, :structure, :style, :repository,
+                :ai_generated, :footer, :bibliography, :sources
 
     def initialize(path)
       @base_dir = File.dirname(File.expand_path(path))
@@ -28,6 +29,10 @@ module Ligarb
       @chapter_numbers = data.fetch("chapter_numbers", true)
       @style           = data.fetch("style", nil)
       @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
 
@@ -39,10 +44,25 @@ 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
 
+    def effective_footer
+      return @footer if @footer
+      return nil unless @ai_generated
+
+      if @language == "ja"
+        "この章の内容は AI によって生成されました。正確性は保証されません。"
+      else
+        "This chapter was generated by AI. Accuracy is not guaranteed."
+      end
+    end
+
     # Returns a flat list of all chapter file paths (excluding part title pages)
     def chapter_paths
       collect_chapter_paths(@structure)
@@ -55,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