ligarb 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbc72fa10dd440a8c1da528db02f314735cae034beed2ae921ba3112caee7fbd
-  data.tar.gz: 14a5b2b990c3bb507f02982c7d9b823f9525a7964b4bd37c69e243316788820a
+  metadata.gz: 10e90698ccef79745b7709265f5657df0354c86000ef85be7401b56cb443da0b
+  data.tar.gz: 5edf902c6f4d06b0fe923f5eb24372b33379bfb50296cadeec04ef308c0cc217
 SHA512:
-  metadata.gz: 528b2af5e5039875052fba85d6765ce8489109bd726ad51732294746b04891bd6c7cd7927ebb98d09ccf97ac4dd3de6107111418691f855760f7e89db9e4f73b
-  data.tar.gz: 6749c352bf7da3170bdbc9605422c8e7c4b59770f3f57dfa030bf96f07d47034e8f95c953815293e3267be477760e95379752cd2e082f550bbd2ca1a7251a1c2
+  metadata.gz: c2d201101b94c3b63405599c21e91c043ac98967fbf6b25035a0e959782c70fbbfa9948981caac86cdb9f25405ebe0e8f2d80c5e5bab6453912a62f1c212cf24
+  data.tar.gz: ed28454394317ade969c4fd8e5dd974b3f34e732208f7089a5f603160a9e9f5172c78d11ef04f872d3b455de18811a56501b9e69e6983ce4d38942bae93d77d4

data/assets/mermaid_check.mjs

@@ -0,0 +1,86 @@
+// Build-time mermaid syntax checker for ligarb.
+//
+// Usage: node mermaid_check.mjs <path/to/mermaid.min.js>
+//   stdin:  JSON array of {"id": <any>, "text": <mermaid source>}
+//   stdout: JSON array of {"id": <any>, "error": <message or null>}
+//
+// Loads the browser UMD bundle of mermaid in Node by stubbing just enough
+// of the DOM (mermaid.parse() only parses; it never renders, but DOMPurify
+// refuses to initialize without something that looks like a document).
+
+const noop = () => {};
+
+// Catch-all stub: any property access returns another stub, so the bundle's
+// incidental DOM touches during initialization succeed silently.
+function makeStub(name, overrides = {}) {
+  const target = function () {};
+  Object.assign(target, overrides);
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop === Symbol.toPrimitive) return () => "";
+      if (prop === "toString") return () => "";
+      if (typeof prop === "symbol") return undefined;
+      if (!(prop in t)) t[prop] = makeStub(name + "." + String(prop));
+      return t[prop];
+    },
+    set(t, prop, v) {
+      t[prop] = v;
+      return true;
+    },
+    apply() {
+      return makeStub(name + "()");
+    },
+    construct() {
+      return makeStub("new " + name);
+    },
+  });
+}
+
+globalThis.window = globalThis;
+// nodeType 9 = DOCUMENT_NODE; DOMPurify checks it to decide it has a real DOM.
+globalThis.document = makeStub("document", { nodeType: 9 });
+globalThis.navigator = { userAgent: "node" };
+globalThis.addEventListener = noop;
+globalThis.location = { href: "http://localhost/", protocol: "http:" };
+globalThis.Element = function Element() {};
+globalThis.HTMLTemplateElement = function HTMLTemplateElement() {};
+globalThis.Node = function Node() {};
+globalThis.NodeFilter = { SHOW_ELEMENT: 1, SHOW_TEXT: 4, SHOW_COMMENT: 128 };
+globalThis.NamedNodeMap = function NamedNodeMap() {};
+globalThis.HTMLFormElement = function HTMLFormElement() {};
+globalThis.DOMParser = function DOMParser() {
+  return makeStub("domparser");
+};
+
+const { readFileSync } = await import("fs");
+const vm = await import("vm");
+
+const mermaidPath = process.argv[2];
+if (!mermaidPath) {
+  console.error("usage: node mermaid_check.mjs <mermaid.min.js>");
+  process.exit(2);
+}
+
+// The bundle starts with "use strict" + top-level `var`, so indirect eval
+// would not create the global binding it expects; a classic script does.
+vm.runInThisContext(readFileSync(mermaidPath, "utf8"), {
+  filename: "mermaid.min.js",
+});
+
+const mermaid = globalThis.mermaid;
+if (!mermaid || typeof mermaid.parse !== "function") {
+  console.error("mermaid.parse is not available after loading the bundle");
+  process.exit(2);
+}
+
+const blocks = JSON.parse(readFileSync(0, "utf8"));
+const results = [];
+for (const block of blocks) {
+  try {
+    await mermaid.parse(block.text);
+    results.push({ id: block.id, error: null });
+  } catch (e) {
+    results.push({ id: block.id, error: String(e && e.message ? e.message : e) });
+  }
+}
+console.log(JSON.stringify(results));

data/assets/style.css

@@ -515,7 +515,14 @@ mark.search-highlight {
   align-items: flex-start;
 }
 
-.theme-toggle {
+.sidebar-header-actions {
+  display: flex;
+  gap: 0.35rem;
+  flex-shrink: 0;
+}
+
+.theme-toggle,
+.sidebar-collapse {
   background: none;
   border: 1px solid var(--color-border);
   border-radius: 4px;
@@ -527,11 +534,30 @@ mark.search-highlight {
   flex-shrink: 0;
 }
 
-.theme-toggle:hover {
+.theme-toggle:hover,
+.sidebar-collapse:hover {
   color: var(--color-text);
   background: var(--color-sidebar-hover);
 }
 
+/* Persistent collapse on wide screens: hide the sidebar and let content
+   reclaim the full width. The floating toggle reappears to bring it back.
+   Scoped to wide viewports so it never fights the off-canvas behavior. */
+@media (min-width: 901px) {
+  .sidebar-collapsed .sidebar {
+    transform: translateX(-100%);
+    transition: transform 0.3s ease;
+  }
+
+  .sidebar-collapsed .content {
+    margin-left: 0;
+  }
+
+  .sidebar-collapsed .sidebar-toggle {
+    display: block;
+  }
+}
+
 /* === Part / Appendix TOC === */
 .toc-part {
   margin-top: 0.5rem;
@@ -643,7 +669,9 @@ mark.search-highlight {
 }
 
 /* === Responsive === */
-@media (max-width: 768px) {
+/* Off-canvas sidebar for narrow viewports. The 900px breakpoint covers iPad
+   portrait (810–834px), which would otherwise keep the fixed desktop sidebar. */
+@media (max-width: 900px) {
   .sidebar {
     transform: translateX(-100%);
     transition: transform 0.3s ease;
@@ -657,6 +685,12 @@ mark.search-highlight {
     display: block;
   }
 
+  /* The in-header collapse button is only meaningful in the fixed desktop
+     layout; off-canvas already hides the sidebar via the floating toggle. */
+  .sidebar-collapse {
+    display: none;
+  }
+
   .content {
     margin-left: 0;
     padding: 2rem 1.5rem;

data/lib/ligarb/builder.rb

@@ -5,6 +5,7 @@ require_relative "config"
 require_relative "chapter"
 require_relative "template"
 require_relative "asset_manager"
+require_relative "mermaid_checker"
 
 module Ligarb
   class Builder
@@ -29,6 +30,8 @@ module Ligarb
       assets.detect(all_chapters)
       assets.provision!
 
+      check_mermaid_syntax(all_chapters, assets, @config.output_path)
+
       index_entries = all_chapters.flat_map { |ch|
         ch.index_entries.map { |e|
           e.class.new(term: e.term, display_text: e.display_text,
@@ -77,6 +80,8 @@ module Ligarb
       assets.detect(all_lang_chapters)
       assets.provision!
 
+      check_mermaid_syntax(all_lang_chapters, assets, output_path)
+
       gr_config = langs.first && langs.first[:config]
       html = Template.new.render_multilang(langs: langs, assets: assets,
                                            hub_data: hub_data,
@@ -124,6 +129,16 @@ module Ligarb
       }
     end
 
+    # Validate mermaid block syntax with the downloaded mermaid.min.js under
+    # Node. Warns (with file:line) but never fails the build; skipped when
+    # Node is unavailable.
+    def check_mermaid_syntax(chapters, assets, output_path)
+      return unless assets.need?(:mermaid)
+
+      mermaid_js = File.join(output_path, "js", "mermaid.min.js")
+      MermaidChecker.check(chapters, mermaid_js)
+    end
+
     # StructNode mirrors Config::StructEntry but holds loaded Chapter objects
     StructNode = Struct.new(:type, :chapter, :children, keyword_init: true)
 

data/lib/ligarb/chapter.rb

@@ -7,12 +7,14 @@ module Ligarb
   class Chapter
     class CrossReferenceError < StandardError; end
 
-    attr_reader :title, :slug, :html, :headings, :number, :appendix_letter, :index_entries, :cite_entries
+    attr_reader :title, :slug, :html, :headings, :number, :appendix_letter, :index_entries, :cite_entries,
+                :path, :mermaid_blocks
     attr_accessor :part_title, :cover, :relative_path
 
     Heading = Struct.new(:level, :text, :id, :display_text, keyword_init: true)
     IndexEntry = Struct.new(:term, :display_text, :chapter_slug, :anchor_id, keyword_init: true)
     CiteEntry = Struct.new(:key, :display_text, :chapter_slug, :anchor_id, keyword_init: true)
+    MermaidBlock = Struct.new(:text, :line, keyword_init: true)
 
     def initialize(path, base_dir, slug_prefix: nil)
       @path     = path
@@ -167,11 +169,14 @@ module Ligarb
     end
 
     def convert_special_code_blocks(html)
+      @mermaid_blocks = []
+      @mermaid_search_pos = 0
       html.gsub(%r{<pre><code class="language-(mermaid|math|functionplot)">(.*?)</code></pre>}m) do
         lang = $1
         raw = decode_entities($2)
         case lang
         when "mermaid"
+          @mermaid_blocks << MermaidBlock.new(text: raw, line: find_source_line(raw))
           escaped = raw.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
           %(<div class="mermaid">\n#{raw}</div>) +
             %(<details class="mermaid-source"><summary>mermaid source</summary><pre>#{escaped}</pre></details>)
@@ -183,6 +188,21 @@ module Ligarb
       end
     end
 
+    # Best-effort: locate the first content line of a mermaid block in the
+    # Markdown source. Scans forward from the previous match so repeated
+    # blocks map to successive locations. Returns a 1-based line number or nil.
+    def find_source_line(block_text)
+      first = block_text.each_line.map(&:chomp).find { |l| !l.strip.empty? }
+      return nil unless first
+
+      lines = @source.lines
+      idx = (@mermaid_search_pos...lines.size).find { |i| lines[i].chomp == first }
+      return nil unless idx
+
+      @mermaid_search_pos = idx + 1
+      idx + 1
+    end
+
     def convert_inline_math(html)
       # Protect <pre>...</pre> and <code>...</code> from conversion
       placeholders = []

data/lib/ligarb/cli.rb

@@ -19,25 +19,31 @@ module Ligarb
         Initializer.new(args.first).run
       when "setup-github-review"
         require_relative "github_review"
-        directory = args.reject { |a| a.start_with?("--") }.first
-        GithubReview.run(directory)
+        owner_idx = args.index("--owner") || args.index("--user")
+        owner = owner_idx ? args[owner_idx + 1] : nil
+        abort "Error: --owner requires a value (e.g. --owner my-org)" if owner_idx && (owner.nil? || owner.start_with?("--"))
+        positional = args.each_index.reject { |i| args[i].start_with?("--") || i == owner_idx&.+(1) }
+        directory = positional.map { |i| args[i] }.first
+        GithubReview.run(directory, owner: owner)
       when "serve"
-        config_paths = args.reject { |a| a.start_with?("--") }
+        port, port_idx = parse_port(args)
+        host, host_idx = parse_host(args)
+        # Drop flags and the --port/--host values so they aren't mistaken for CONFIG paths.
+        value_indices = [port_idx, host_idx].compact.map { |i| i + 1 }
+        config_paths = args.each_index
+                           .reject { |i| args[i].start_with?("--") || value_indices.include?(i) }
+                           .map { |i| args[i] }
         config_paths = ["book.yml"] if config_paths.empty?
-        port_idx = args.index("--port")
-        port = port_idx ? args[port_idx + 1].to_i : 3000
-        abort "Error: port must be 1-65535" unless (1..65535).include?(port)
         multi = args.include?("--multi")
         require_relative "server"
-        Server.new(config_paths, port: port, multi: multi).start
+        Server.new(config_paths, port: port, host: host, multi: multi).start
       when "librarium"
         config_paths = Dir.glob("*/book.yml").sort
         abort "Error: no */book.yml found in current directory" if config_paths.empty?
-        port_idx = args.index("--port")
-        port = port_idx ? args[port_idx + 1].to_i : 3000
-        abort "Error: port must be 1-65535" unless (1..65535).include?(port)
+        port, = parse_port(args)
+        host, = parse_host(args)
         require_relative "server"
-        Server.new(config_paths, port: port, multi: true).start
+        Server.new(config_paths, port: port, host: host, multi: true).start
       when "write"
         require_relative "writer"
         begin
@@ -65,17 +71,48 @@ module Ligarb
       end
     end
 
+    # Parses `--port N` from args. Returns [port, flag_index]; port defaults to
+    # 3000 when --port is absent (flag_index is then nil). Aborts on a missing
+    # or out-of-range value.
+    def parse_port(args)
+      idx = args.index("--port")
+      return [3000, nil] unless idx
+
+      value = args[idx + 1]
+      abort "Error: --port requires a value (e.g. --port 8080)" if value.nil? || value.start_with?("--")
+      port = value.to_i
+      abort "Error: port must be 1-65535" unless (1..65535).include?(port)
+      [port, idx]
+    end
+
+    # Parses `--host ADDR` from args. Returns [host, flag_index]; host defaults
+    # to "127.0.0.1" (loopback only) when --host is absent (flag_index is then
+    # nil). Aborts on a missing value.
+    def parse_host(args)
+      idx = args.index("--host")
+      return ["127.0.0.1", nil] unless idx
+
+      value = args[idx + 1]
+      abort "Error: --host requires a value (e.g. --host 0.0.0.0)" if value.nil? || value.start_with?("--")
+      [value, idx]
+    end
+
     def print_usage
       puts <<~USAGE
         ligarb #{VERSION} - Generate a single-page HTML book from Markdown files
 
         Usage:
           ligarb init [DIRECTORY]  Create a new book project
-          ligarb setup-github-review [DIRECTORY]
+          ligarb setup-github-review [DIRECTORY] [--owner NAME]
                                   Set up (or update) GitHub Pages + review workflows
+                                  (--owner/--user seeds repository: owner when unset)
           ligarb build [CONFIG]    Build the HTML book (default CONFIG: book.yml)
-          ligarb serve [CONFIG]   Serve the book with live reload and review UI
-          ligarb librarium       Serve all */book.yml as a multi-book library
+          ligarb serve [CONFIG] [--port N] [--host ADDR]
+                                  Serve the book with live reload and review UI
+                                  (--host ADDR binds the interface; default
+                                  127.0.0.1. Use 0.0.0.0 to expose on the LAN)
+          ligarb librarium [--port N] [--host ADDR]
+                                  Serve all */book.yml as a multi-book library
           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)

data/lib/ligarb/config.rb

@@ -11,7 +11,9 @@ module Ligarb
     # config file that was directly passed to `ligarb build`.
     INHERITABLE_KEYS = %w[author language chapter_numbers style
                           repository ai_generated footer bibliography
-                          github_review].freeze
+                          github_review site_url].freeze
+    # `description` is intentionally not inheritable: it is usually
+    # language-specific, so each translation should set its own.
 
     # Represents a structural entry in the book
     StructEntry = Struct.new(:type, :path, :children, keyword_init: true)
@@ -26,7 +28,7 @@ module Ligarb
     attr_reader :title, :author, :language, :output_dir, :base_dir,
                 :chapter_numbers, :structure, :style, :repository,
                 :ai_generated, :footer, :bibliography, :sources,
-                :translations, :github_review
+                :translations, :github_review, :description, :site_url
 
     def initialize(path, parent_data: nil)
       @base_dir = File.dirname(File.expand_path(path))
@@ -60,6 +62,8 @@ module Ligarb
       validate!(data)
 
       @title           = data["title"]
+      @description     = data.fetch("description", nil)
+      @site_url        = data.fetch("site_url", nil)
       @author          = data.fetch("author", "")
       @language        = data.fetch("language", "en")
       @output_dir      = data.fetch("output_dir", "build")

data/lib/ligarb/github_review.rb

@@ -43,7 +43,7 @@ module Ligarb
     # feedback UI in book.yml, and prints the remaining manual-setup steps.
     # Safe to re-run to pull in updated templates (generated files are
     # overwritten; book.yml is not).
-    def self.run(directory = nil)
+    def self.run(directory = nil, owner: nil)
       target = File.expand_path(directory || ".")
       unless File.exist?(File.join(target, "book.yml"))
         $stderr.puts "Error: book.yml not found in #{target}"
@@ -51,18 +51,21 @@ module Ligarb
         exit 1
       end
 
-      reviewer = new(target)
+      reviewer = new(target, owner: owner)
       # book.yml edits must run BEFORE generate so the templates (SETUP.sh,
       # issue forms, README) are substituted with the resolved repository.
       repository = reviewer.ensure_repository_in_book_yml
+      site_url = reviewer.ensure_site_url_in_book_yml
       enabled = reviewer.enable_in_book_yml
       readme = reviewer.create_readme_if_absent
       result = reviewer.generate
-      reviewer.print_notice(result, repository: repository, enabled: enabled, readme: readme)
+      reviewer.print_notice(result, repository: repository, site_url: site_url,
+                            enabled: enabled, readme: readme)
     end
 
-    def initialize(target)
+    def initialize(target, owner: nil)
       @target = File.expand_path(target)
+      @owner = owner
     end
 
     # Writes all template files into the project, substituting __OWNER__ /
@@ -110,23 +113,64 @@ module Ligarb
     end
 
     # Seeds a default `repository:` in book.yml when it has none, guessing
-    # https://github.com/<os-user>/<dir-name>. This drives __OWNER__/__REPO__
-    # substitution and the GH Pages link; the user edits it if the guess is
-    # wrong. Returns :added, :present, or :unsupported. (@default_repository is
-    # set to the guessed URL when :added, for the notice.)
+    # https://github.com/<owner>/<dir-name>. <owner> is the --owner/--user flag
+    # when given, else $USER. This drives __OWNER__/__REPO__ substitution and
+    # the GH Pages link; the user edits it if the guess is wrong. Returns
+    # :added, :present, or :unsupported. (@default_repository is set to the
+    # guessed URL when :added, for the notice.)
+    #
+    # Aborts if --owner was given but book.yml already has a `repository:`, since
+    # we never rewrite an existing repository — the user edits it themselves.
     def ensure_repository_in_book_yml
       book_yml = File.join(@target, "book.yml")
       data = YAML.safe_load_file(book_yml)
       return :unsupported unless data.is_a?(Hash)
-      return :present if data.key?("repository")
+      if data.key?("repository")
+        if @owner
+          abort "Error: --owner was given but book.yml already has 'repository: #{data["repository"]}'.\n" \
+                "Edit 'repository:' in book.yml directly to change the owner, then re-run setup-github-review."
+        end
+        return :present
+      end
 
-      user = ENV["USER"] || ENV["USERNAME"] || "your-github-account"
-      @default_repository = "https://github.com/#{user}/#{File.basename(@target)}"
+      owner = @owner || ENV["USER"] || ENV["USERNAME"] || "your-github-account"
+      @default_repository = "https://github.com/#{owner}/#{File.basename(@target)}"
       content = File.read(book_yml).rstrip
       File.write(book_yml, %(#{content}\n\nrepository: "#{@default_repository}"\n))
       :added
     end
 
+    # Seeds a default `site_url:` in book.yml when it has none, deriving the
+    # GitHub Pages URL from `repository`. Drives og:url / canonical in the build
+    # output; the user edits it for custom domains or other hosting. Returns
+    # :added, :present, or :skipped (when no GitHub repository to derive from).
+    # (@default_site_url is set to the derived URL when :added, for the notice.)
+    def ensure_site_url_in_book_yml
+      book_yml = File.join(@target, "book.yml")
+      data = YAML.safe_load_file(book_yml)
+      return :skipped unless data.is_a?(Hash)
+      return :present if data.key?("site_url")
+
+      owner, repo = extract_owner_repo
+      return :skipped unless owner && repo
+
+      @default_site_url = pages_url(owner, repo)
+      content = File.read(book_yml).rstrip
+      File.write(book_yml, %(#{content}\n\nsite_url: "#{@default_site_url}"\n))
+      :added
+    end
+
+    # GitHub Pages URL for a repo. A repository named "<owner>.github.io" is the
+    # owner's user/org site served at the domain root; everything else is a
+    # project site served under /<repo>/.
+    def pages_url(owner, repo)
+      if repo.downcase == "#{owner.downcase}.github.io"
+        "https://#{owner}.github.io/"
+      else
+        "https://#{owner}.github.io/#{repo}/"
+      end
+    end
+
     # Creates a project README.md that links to the published GitHub Pages site,
     # but only when one does not already exist (the reader's own README is never
     # overwritten). Returns :created or :present.
@@ -135,7 +179,7 @@ module Ligarb
       return :present if File.exist?(readme)
 
       owner, repo = extract_owner_repo
-      pages  = owner && repo ? "https://#{owner}.github.io/#{repo}/" : "https://__OWNER__.github.io/__REPO__/"
+      pages  = owner && repo ? pages_url(owner, repo) : "https://__OWNER__.github.io/__REPO__/"
       issues = owner && repo ? "https://github.com/#{owner}/#{repo}/issues/new?template=book-feedback.yml" \
                              : "https://github.com/__OWNER__/__REPO__/issues/new?template=book-feedback.yml"
       title = book_title.to_s.empty? ? "Book" : book_title
@@ -164,7 +208,7 @@ module Ligarb
       :created
     end
 
-    def print_notice(result, repository:, enabled:, readme:)
+    def print_notice(result, repository:, site_url:, enabled:, readme:)
       puts "Set up GitHub review scaffolding in #{@target}:"
       result.created.each { |path| puts "  created    #{path}" }
       result.updated.each { |path| puts "  updated    #{path}" }
@@ -172,6 +216,9 @@ module Ligarb
       case repository
       when :added then puts "  updated    book.yml (repository: #{@default_repository})"
       end
+      case site_url
+      when :added then puts "  updated    book.yml (site_url: #{@default_site_url})"
+      end
       case enabled
       when :added   then puts "  updated    book.yml (github_review.enabled: true)"
       when :present then puts "  kept       book.yml github_review setting"

data/lib/ligarb/mermaid_checker.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Ligarb
+  # Build-time syntax check for mermaid blocks. Runs the downloaded
+  # mermaid.min.js under Node (assets/mermaid_check.mjs) and calls
+  # mermaid.parse() on each block. Reports syntax errors as warnings with
+  # file:line locations; never fails the build (the generated HTML already
+  # shows an error box for broken diagrams at view time).
+  class MermaidChecker
+    HARNESS = File.expand_path("../../assets/mermaid_check.mjs", __dir__)
+
+    # chapters: Chapter objects (mermaid_blocks may be empty)
+    # mermaid_js: path to the provisioned mermaid.min.js
+    # Returns the number of blocks with syntax errors.
+    def self.check(chapters, mermaid_js)
+      new(chapters, mermaid_js).check
+    end
+
+    def initialize(chapters, mermaid_js)
+      @chapters = chapters
+      @mermaid_js = mermaid_js
+    end
+
+    def check
+      blocks = collect_blocks
+      return 0 if blocks.empty?
+
+      unless File.exist?(@mermaid_js)
+        warn "Warning: #{@mermaid_js} not found; skipping mermaid syntax check"
+        return 0
+      end
+
+      results = run_harness(blocks)
+      return 0 unless results
+
+      error_count = 0
+      results.each do |result|
+        error = result["error"]
+        next unless error
+
+        error_count += 1
+        block = blocks[result["id"]]
+        warn "Warning: mermaid syntax error in #{block[:location]}"
+        error.each_line { |l| warn "  #{l.chomp}" }
+      end
+      error_count
+    end
+
+    private
+
+    def collect_blocks
+      blocks = []
+      @chapters.each do |ch|
+        ch.mermaid_blocks.each do |block|
+          location = block.line ? "#{ch.path}:#{block.line}" : ch.path
+          blocks << { id: blocks.size, text: block.text, location: location }
+        end
+      end
+      blocks
+    end
+
+    def run_harness(blocks)
+      input = JSON.generate(blocks.map { |b| { id: b[:id], text: b[:text] } })
+      stdout, stderr, status = Open3.capture3("node", HARNESS, @mermaid_js, stdin_data: input)
+      unless status.success?
+        warn "Warning: mermaid syntax check failed to run (node exited #{status.exitstatus}); skipping"
+        stderr.each_line.first(3).each { |l| warn "  #{l.chomp}" } if stderr && !stderr.empty?
+        return nil
+      end
+      JSON.parse(stdout)
+    rescue Errno::ENOENT
+      warn "Warning: node not found; skipping mermaid syntax check"
+      nil
+    rescue JSON::ParserError
+      warn "Warning: mermaid syntax check produced unexpected output; skipping"
+      nil
+    end
+  end
+end

data/lib/ligarb/server.rb

@@ -14,8 +14,9 @@ module Ligarb
 
     BookEntry = Struct.new(:slug, :config, :config_path, :build_dir, :store, :claude, keyword_init: true)
 
-    def initialize(config_paths, port: 3000, multi: false)
+    def initialize(config_paths, port: 3000, host: "127.0.0.1", multi: false)
       @port = port
+      @host = host
       @assets_dir = File.join(File.dirname(__FILE__), "..", "..", "assets")
       @sse_clients = [] # [[slug, queue], ...]
       @sse_mutex = Mutex.new
@@ -51,9 +52,11 @@ module Ligarb
         Builder.new(book.config_path).build
       end
 
+      warn_if_exposed
+
       server = WEBrick::HTTPServer.new(
         Port: @port,
-        BindAddress: "127.0.0.1",
+        BindAddress: @host,
         Logger: WEBrick::Log.new($stderr, WEBrick::Log::INFO),
         AccessLog: [[File.open(File::NULL, "w"), WEBrick::AccessLog::COMMON_LOG_FORMAT]],
         RequestBodyMaxSize: 50 * 1024 * 1024
@@ -67,12 +70,13 @@ module Ligarb
 
       @books.each_value { |book| start_build_watcher(book) }
 
+      base_url = "http://#{display_host}:#{@port}"
       if @multi
-        puts "Serving #{@books.size} books at http://localhost:#{@port}"
+        puts "Serving #{@books.size} books at #{base_url}"
         @books.each_value { |b| puts "  /#{b.slug}/ — #{b.config.title}" }
       else
         book = @books.values.first
-        puts "Serving #{book.config.title} at http://localhost:#{@port}"
+        puts "Serving #{book.config.title} at #{base_url}"
         puts "  Build directory: #{book.build_dir}"
       end
       puts "  Press Ctrl+C to stop"
@@ -82,6 +86,26 @@ module Ligarb
 
     private
 
+    LOOPBACK_HOSTS = %w[127.0.0.1 ::1 localhost].freeze
+
+    # Host to print in URLs. A wildcard or unspecified bind address is reachable
+    # via localhost, so show that; otherwise show the concrete bind address.
+    def display_host
+      return "localhost" if LOOPBACK_HOSTS.include?(@host) || ["0.0.0.0", "::", ""].include?(@host)
+      @host
+    end
+
+    # When binding beyond loopback, the review/feedback APIs (which can run
+    # Claude and write files) become reachable from the network. Warn so this
+    # is never a surprise.
+    def warn_if_exposed
+      return if LOOPBACK_HOSTS.include?(@host)
+
+      warn "Warning: binding to #{@host} exposes ligarb serve on the network."
+      warn "  The review/feedback APIs (file writes, Claude runs) will be reachable by other hosts."
+      warn "  Only do this on a trusted network."
+    end
+
     # ── Operation Queue ──
 
     def operation_worker
@@ -701,29 +725,41 @@ module Ligarb
 
     # ── API routing ──
 
+    # Same-origin check for state-changing requests. The request's Origin (or
+    # Referer) must match the Host the browser actually connected to, so this
+    # works for any bind address (loopback, a LAN IP, a hostname, 0.0.0.0)
+    # without trusting the bind address itself. A cross-site request carries the
+    # attacker's Origin while Host stays ours, so it is rejected.
     def csrf_safe?(req)
       return true if req.request_method == "GET"
 
+      host = req["Host"]
+      return false if host.nil? || host.empty?
+
       origin = req["Origin"]
-      if origin && !origin.empty?
-        return origin == "http://localhost:#{@port}" ||
-               origin == "http://127.0.0.1:#{@port}"
-      end
+      return same_authority?(origin, host) if origin && !origin.empty?
 
       referer = req["Referer"]
-      if referer && !referer.empty?
-        uri = URI.parse(referer) rescue nil
-        return uri && %w[localhost 127.0.0.1].include?(uri.host) && uri.port == @port
-      end
+      return same_authority?(referer, host) if referer && !referer.empty?
 
       false
     end
 
+    # True when the URL's authority (host[:port]) equals the Host header.
+    def same_authority?(url, host_header)
+      uri = URI.parse(url) rescue nil
+      return false unless uri&.host
+
+      candidates = [uri.host]
+      candidates << "#{uri.host}:#{uri.port}" if uri.port
+      candidates.include?(host_header)
+    end
+
     def handle_api(req, res)
       unless csrf_safe?(req)
         res.status = 403
         res["Content-Type"] = "application/json; charset=utf-8"
-        res.body = JSON.generate({ error: "CSRF check failed: request must originate from localhost" })
+        res.body = JSON.generate({ error: "CSRF check failed: request must be same-origin" })
         return
       end
 

data/lib/ligarb/template.rb

@@ -39,6 +39,9 @@ module Ligarb
       b.local_variable_set(:multilang, false)
       b.local_variable_set(:langs, [])
       b.local_variable_set(:feedback, load_feedback(github_review))
+      b.local_variable_set(:og_description, og_description(config, chapters))
+      b.local_variable_set(:og_locale, og_locale(config.language))
+      b.local_variable_set(:og_url, og_url(config))
 
       ERB.new(template, trim_mode: "-").result(b)
     end
@@ -93,6 +96,9 @@ module Ligarb
       b.local_variable_set(:multilang, true)
       b.local_variable_set(:langs, lang_data)
       b.local_variable_set(:feedback, load_feedback(github_review))
+      b.local_variable_set(:og_description, og_description(first_config, first[:chapters]))
+      b.local_variable_set(:og_locale, og_locale(first_config.language))
+      b.local_variable_set(:og_url, og_url(first_config))
 
       ERB.new(template, trim_mode: "-").result(b)
     end
@@ -132,6 +138,51 @@ module Ligarb
       ERB::Util.html_escape(s.to_s)
     end
 
+    # og:locale wants ll_CC; ligarb only knows the bare language code, so map
+    # the common ones and fall back to the raw value for anything else.
+    OG_LOCALES = { "ja" => "ja_JP", "en" => "en_US" }.freeze
+
+    def og_locale(language)
+      OG_LOCALES.fetch(language, language)
+    end
+
+    # Canonical URL for og:url, taken verbatim from `site_url` (the published
+    # root of this build). Returns nil when unset so the tag is omitted — a
+    # wrong canonical URL is worse than none.
+    def og_url(config)
+      url = config.site_url.to_s.strip
+      url.empty? ? nil : url
+    end
+
+    # Resolve the OGP description: the configured `description`, or, failing
+    # that, the first real paragraph of prose from the cover (or first) chapter.
+    # Returns nil when nothing usable is found.
+    def og_description(config, chapters)
+      explicit = config.description.to_s.strip
+      return explicit unless explicit.empty?
+
+      auto_description(chapters)
+    end
+
+    DESCRIPTION_LIMIT = 200
+
+    def auto_description(chapters)
+      chapter = chapters.find(&:cover?) || chapters.first
+      return nil unless chapter
+
+      # First <p> with real prose (tags stripped, whitespace collapsed).
+      # Image-only paragraphs (e.g. a cover logo) strip to empty and are skipped.
+      chapter.html.scan(%r{<p[^>]*>(.*?)</p>}m) do |(inner)|
+        text = inner.gsub(/<[^>]+>/, "").gsub(/\s+/, " ").strip
+        text = text.gsub("&amp;", "&").gsub("&lt;", "<").gsub("&gt;", ">").gsub("&quot;", '"').gsub("&#39;", "'")
+        next if text.empty?
+
+        return text.length > DESCRIPTION_LIMIT ? "#{text[0, DESCRIPTION_LIMIT - 1].rstrip}…" : text
+      end
+
+      nil
+    end
+
     # Build a sorted tree structure for the index.
     # Returns: { "A" => [ { term: "Algorithm", refs: [...] },
     #                      { term: "Array", refs: [...], children: [ { term: "sort", refs: [...] } ] } ],

data/lib/ligarb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ligarb
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/templates/book.html.erb

@@ -4,6 +4,22 @@
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title><%= h(title) %></title>
+<meta property="og:type" content="book">
+<meta property="og:title" content="<%= h(title) %>">
+<meta property="og:site_name" content="<%= h(title) %>">
+<meta property="og:locale" content="<%= h(og_locale) %>">
+<%- if og_url -%>
+<meta property="og:url" content="<%= h(og_url) %>">
+<link rel="canonical" href="<%= h(og_url) %>">
+<%- end -%>
+<%- if og_description && !og_description.empty? -%>
+<meta name="description" content="<%= h(og_description) %>">
+<meta property="og:description" content="<%= h(og_description) %>">
+<%- end -%>
+<meta name="twitter:card" content="summary">
+<%- if author && !author.to_s.empty? -%>
+<meta property="book:author" content="<%= h(author) %>">
+<%- end -%>
 <%- if ai_generated -%>
 <meta name="robots" content="noindex, nofollow, noarchive">
 <meta name="robots" content="noai, noimageai">
@@ -50,7 +66,10 @@
       <h1 class="book-title"><%= h(title) %></h1>
       <%- end -%>
 <%- end -%>
+      <div class="sidebar-header-actions">
       <button class="theme-toggle" id="theme-toggle" aria-label="Toggle dark mode" title="Toggle dark mode">&#9790;</button>
+      <button class="sidebar-collapse" id="sidebar-collapse" aria-label="Collapse sidebar" title="Collapse sidebar">&#171;</button>
+      </div>
     </div>
 <%- if multilang -%>
   <%- langs.each do |ld| -%>
@@ -256,7 +275,7 @@
 <%- if multilang -%>
   <%- langs.each do |ld| -%>
   <%- ld[:chapters].select(&:cover?).each do |chapter| -%>
-  <section class="chapter cover-page" id="chapter-<%= chapter.slug %>" data-lang="<%= ld[:lang] %>" style="display: none;">
+  <section class="chapter cover-page" id="chapter-<%= chapter.slug %>" data-lang="<%= ld[:lang] %>"<%= src_attrs(chapter, feedback) %> style="display: none;">
     <%= chapter.html %>
   </section>
   <%- end -%>
@@ -373,7 +392,7 @@
   <%- end -%>
 <%- else -%>
   <%- chapters.select(&:cover?).each do |chapter| -%>
-  <section class="chapter cover-page" id="chapter-<%= chapter.slug %>" style="display: none;">
+  <section class="chapter cover-page" id="chapter-<%= chapter.slug %>"<%= src_attrs(chapter, feedback) %> style="display: none;">
     <%= chapter.html %>
   </section>
   <%- end -%>
@@ -1041,18 +1060,44 @@
     }
   }
 
-  // Sidebar toggle for mobile
+  // Sidebar show/hide. Two behaviors share one breakpoint (kept in sync with
+  // the 900px media query in style.css):
+  //   - narrow (iPad portrait, phones): the sidebar is off-canvas; the floating
+  //     toggle slides it in/out as an overlay.
+  //   - wide (desktop): the sidebar is fixed; the in-header « button collapses
+  //     it so the content reclaims full width. The collapsed state persists.
   var toggle = document.getElementById('sidebar-toggle');
+  var collapseBtn = document.getElementById('sidebar-collapse');
   var sidebar = document.getElementById('sidebar');
+  var narrow = window.matchMedia('(max-width: 900px)');
+
+  function setCollapsed(state) {
+    document.body.classList.toggle('sidebar-collapsed', state);
+    localStorage.setItem('ligarb-sidebar-collapsed', state ? '1' : '0');
+  }
+
+  if (localStorage.getItem('ligarb-sidebar-collapsed') === '1') {
+    document.body.classList.add('sidebar-collapsed');
+  }
+
   toggle.addEventListener('click', function() {
-    sidebar.classList.toggle('open');
+    if (narrow.matches) {
+      sidebar.classList.toggle('open');   // off-canvas overlay
+    } else {
+      setCollapsed(false);                // wide: the floating toggle only
+                                          // shows when collapsed, so reopen
+    }
+  });
+
+  collapseBtn.addEventListener('click', function() {
+    setCollapsed(true);
   });
 
-  // Close sidebar when clicking a link on mobile
+  // Close the off-canvas sidebar after tapping a link (narrow only)
   var tocLinks = document.querySelectorAll('.toc a');
   tocLinks.forEach(function(link) {
     link.addEventListener('click', function() {
-      if (window.innerWidth <= 768) {
+      if (narrow.matches) {
         sidebar.classList.remove('open');
       }
     });

data/templates/github_review/.github/workflows/deploy-book.yml

@@ -1,7 +1,8 @@
 name: Build and deploy book
 
 # master に push すると ligarb で本をビルドし、GitHub Pages に公開する。
-# 事前設定: リポジトリ Settings > Pages > Source を "GitHub Actions" にしておくこと。
+# Pages は configure-pages の enablement: true で自動有効化されるため事前設定は不要。
+# 手動で設定する場合は Settings > Pages > Source を "GitHub Actions" にする。
 
 on:
   push:
@@ -31,6 +32,9 @@ jobs:
       - name: Build book
         run: ligarb build   # build/index.html を生成
       - uses: actions/configure-pages@v5
+        with:
+          # Pages が未設定でもワークフロー側で有効化する（初回 push のレースを防ぐ）。
+          enablement: true
       - uses: actions/upload-pages-artifact@v3
         with:
           path: build

data/templates/github_review/SETUP.md

@@ -108,7 +108,9 @@ gh を使わない場合や、設定の意味を確認したいときの参照
 
 ### GitHub Pages（手順 C-4 の代替）
 
-- Settings > Pages > Source を **"GitHub Actions"** にする。
+- 基本的には設定不要。`deploy-book.yml` が初回実行時に Pages を自動で有効化する
+  （`configure-pages` の `enablement: true`）。
+- 手動で設定する場合は Settings > Pages > Source を **"GitHub Actions"** にする。
 
 ### Actions の権限（手順 C-5 の代替）
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ligarb
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - ligarb contributors
@@ -102,6 +102,7 @@ extra_rdoc_files: []
 files:
 - assets/feedback.css
 - assets/feedback.js
+- assets/mermaid_check.mjs
 - assets/review.css
 - assets/review.js
 - assets/serve.js
@@ -116,6 +117,7 @@ files:
 - lib/ligarb/github_review.rb
 - lib/ligarb/initializer.rb
 - lib/ligarb/inotify.rb
+- lib/ligarb/mermaid_checker.rb
 - lib/ligarb/review_store.rb
 - lib/ligarb/server.rb
 - lib/ligarb/template.rb