ligarb 0.3.0 → 0.5.0

data/assets/serve.js

@@ -0,0 +1,76 @@
+// ligarb serve — SSE-based live reload + reload button
+(function() {
+  'use strict';
+
+  var refreshing = false;
+
+  // Create reload button (hidden by default, shown when build changes)
+  var reloadBtn = document.createElement('button');
+  reloadBtn.id = 'ligarb-reload';
+  reloadBtn.innerHTML = '↻';
+  reloadBtn.title = 'New build available — click to reload';
+  reloadBtn.style.display = 'none';
+  reloadBtn.addEventListener('click', function() {
+    refreshContent();
+  });
+  document.body.appendChild(reloadBtn);
+
+  function showReloadButton() {
+    reloadBtn.style.display = 'flex';
+    reloadBtn.classList.add('has-update');
+    reloadBtn.classList.remove('refreshing');
+  }
+
+  function hideReloadButton() {
+    reloadBtn.style.display = 'none';
+    reloadBtn.classList.remove('has-update', 'refreshing');
+  }
+
+  // Refresh book content without full page reload
+  function refreshContent() {
+    if (refreshing) return;
+    refreshing = true;
+    reloadBtn.classList.remove('has-update');
+    reloadBtn.classList.add('refreshing');
+
+    fetch((window._ligarbBase || '/') + '?_t=' + Date.now())
+      .then(function(r) { return r.text(); })
+      .then(function(html) {
+        var parser = new DOMParser();
+        var doc = parser.parseFromString(html, 'text/html');
+        var newMain = doc.getElementById('content');
+        var oldMain = document.getElementById('content');
+        if (newMain && oldMain) {
+          var scrollY = window.scrollY;
+          oldMain.innerHTML = newMain.innerHTML;
+          var hash = location.hash.replace('#', '');
+          if (hash) {
+            // Show the current chapter without scrolling to top
+            var slug = hash.split('--')[0];
+            var chapters = oldMain.querySelectorAll('.chapter');
+            chapters.forEach(function(el) {
+              el.style.display = el.id === 'chapter-' + slug ? 'block' : 'none';
+            });
+          }
+          window.scrollTo(0, scrollY);
+        }
+        refreshing = false;
+        hideReloadButton();
+      })
+      .catch(function() {
+        refreshing = false;
+        hideReloadButton();
+        location.reload();
+      });
+  }
+
+  // SSE connection
+  var eventSource = new EventSource((window._ligarbAPI || '/_ligarb') + '/events');
+
+  eventSource.addEventListener('build_updated', function() {
+    showReloadButton();
+  });
+
+  // Expose for review.js
+  window._ligarbEvents = eventSource;
+})();

data/assets/style.css

@@ -368,6 +368,18 @@ body {
   margin-right: 0.5rem;
 }
 
+.search-match-count {
+  display: inline-block;
+  background: var(--color-accent);
+  color: #fff;
+  font-size: 0.7rem;
+  padding: 0.05em 0.45em;
+  border-radius: 8px;
+  margin-left: 0.4em;
+  vertical-align: middle;
+  line-height: 1.4;
+}
+
 /* Search highlight */
 mark.search-highlight {
   background: #fef08a;
@@ -624,6 +636,61 @@ mark.search-highlight {
   }
 }
 
+/* === Bibliography === */
+.bibliography-list {
+  list-style: none;
+  padding-left: 0;
+}
+
+.bibliography-list li {
+  margin-bottom: 0.75rem;
+  padding-left: 1.5rem;
+  text-indent: -1.5rem;
+  line-height: 1.5;
+}
+
+.bibliography-list li a {
+  color: var(--color-accent);
+  text-decoration: none;
+}
+
+.bibliography-list li a:hover {
+  text-decoration: underline;
+}
+
+.cite-ref {
+  font-size: 0.8em;
+}
+
+.bib-label {
+  font-weight: 600;
+  color: var(--color-text-muted);
+  margin-right: 0.3em;
+}
+
+.cite-ref a {
+  color: var(--color-accent);
+  text-decoration: none;
+  font-weight: 600;
+}
+
+.cite-ref a:hover {
+  text-decoration: underline;
+}
+
+.cite-missing {
+  color: #d32f2f;
+  background: #ffebee;
+  padding: 0 3px;
+  border-radius: 2px;
+  cursor: help;
+}
+
+[data-theme="dark"] .cite-missing {
+  color: #ef9a9a;
+  background: rgba(211, 47, 47, 0.15);
+}
+
 /* === Index === */
 .index-group {
   margin-bottom: 1.5rem;
@@ -670,6 +737,34 @@ mark.search-highlight {
   text-decoration: underline;
 }
 
+/* === AI Generated Notice === */
+.ai-badge {
+  display: inline-block;
+  font-size: 0.7rem;
+  font-weight: 600;
+  color: #ca8a04;
+  background: #fefce8;
+  border: 1px solid #facc15;
+  border-radius: 3px;
+  padding: 0.1rem 0.4rem;
+  margin-top: 0.3rem;
+  letter-spacing: 0.03em;
+}
+
+[data-theme="dark"] .ai-badge {
+  color: #fbbf24;
+  background: #2e2a1a;
+  border-color: #854d0e;
+}
+
+.chapter-footer {
+  margin-top: 2rem;
+  padding: 0.5rem 0.75rem;
+  font-size: 0.8rem;
+  color: var(--color-text-muted);
+  border-top: 1px solid var(--color-border);
+}
+
 /* === Print === */
 @media print {
   .sidebar,

data/lib/ligarb/asset_manager.rb

@@ -22,7 +22,7 @@ module Ligarb
         },
       },
       katex: {
-        fence_pattern: /class="math-block"/,
+        fence_pattern: /class="math-(block|inline)"/,
         files: {
           "js/katex.min.js" => "https://cdn.jsdelivr.net/npm/katex@0.16/dist/katex.min.js",
           "css/katex.min.css" => "https://cdn.jsdelivr.net/npm/katex@0.16/dist/katex.min.css",

data/lib/ligarb/builder.rb

@@ -30,9 +30,12 @@ module Ligarb
         }
       }
 
+      bibliography = resolve_citations!(all_chapters)
+
       html = Template.new.render(config: @config, chapters: all_chapters,
                                  structure: structure, assets: assets,
-                                 index_entries: index_entries)
+                                 index_entries: index_entries,
+                                 bibliography: bibliography)
 
       FileUtils.mkdir_p(@config.output_path)
       output_file = File.join(@config.output_path, "index.html")
@@ -145,6 +148,178 @@ module Ligarb
       end
     end
 
+    def resolve_citations!(all_chapters)
+      bib_path = @config.bibliography_path
+      return [] unless bib_path
+
+      unless File.exist?(bib_path)
+        abort "Error: bibliography file not found: #{bib_path}"
+      end
+
+      bib_data = load_bibliography(bib_path)
+
+      # Validate all cite keys exist
+      cited_keys = {}
+      all_chapters.each do |ch|
+        ch.cite_entries.each do |entry|
+          unless bib_data.key?(entry.key)
+            warn "Warning: unknown bibliography key '#{entry.key}' in chapter #{File.basename(ch.instance_variable_get(:@path))}"
+            next
+          end
+          cited_keys[entry.key] = true
+        end
+      end
+
+      # Post-process each chapter's HTML to insert [author, year] citations
+      all_chapters.each do |ch|
+        ch.instance_variable_set(:@html, ch.html.gsub(%r{<span id="([^"]+)" data-cite-key="([^"]+)">(.*?)</span>}m) do
+          anchor_id = $1
+          key = $2
+          display_text = $3
+          ref = bib_data[key]
+          unless ref
+            next %(<span id="#{anchor_id}">#{display_text}<sup class="cite-ref cite-missing" title="Bibliography entry '#{encode_attr(key)}' not found">[#{encode_attr(key)}?]</sup></span>)
+          end
+          cite_label = format_cite_label(ref)
+          title_text = format_bib_hover(ref)
+          %(<span id="#{anchor_id}">#{display_text}<sup class="cite-ref"><a href="#bib-#{key}" title="#{encode_attr(title_text)}" onclick="showChapterAndScroll('__bibliography__', 'bib-#{key}'); return false;">[#{encode_attr(cite_label)}]</a></sup></span>)
+        end)
+      end
+
+      # Build bibliography list sorted by author then year (only cited entries)
+      cited_keys.keys.map do |key|
+        ref = bib_data[key]
+        {
+          key: key,
+          author: ref["author"],
+          title: ref["title"],
+          year: ref["year"],
+          url: ref["url"],
+          label: format_cite_label(ref),
+          formatted_html: format_bib_html(ref),
+        }
+      end.sort_by { |e| [e[:author].to_s, e[:year].to_s] }
+    end
+
+    def load_bibliography(path)
+      if path.end_with?(".bib")
+        parse_bibtex(File.read(path))
+      else
+        YAML.safe_load_file(path)
+      end
+    end
+
+    def parse_bibtex(source)
+      result = {}
+      # Remove comment lines
+      lines = source.each_line.reject { |l| l.match?(/\A\s*%/) }.join
+
+      # Extract @type{key, ...} blocks
+      lines.scan(/@(\w+)\s*\{\s*([^,]+)\s*,(.*?)\n\s*\}/m) do |type, key, body|
+        entry = {"_type" => type.downcase}
+        body.scan(/(\w+)\s*=\s*(?:\{((?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*)\}|"([^"]*)")/) do |field, brace_val, quote_val|
+          value = (brace_val || quote_val).strip
+          # Remove BibTeX case-protection braces (e.g. {LaTeX} -> LaTeX)
+          value = value.gsub(/\{([^{}]*)\}/, '\1')
+          entry[field.downcase] = value
+        end
+        result[key.strip] = entry
+      end
+
+      result
+    end
+
+    def format_bib_html(ref)
+      type = ref["_type"] || "misc"
+      parts = []
+
+      author = ref["author"]
+      parts << encode_html(author) if author
+
+      title = ref["title"]
+      if title
+        title_html = if ref["url"]
+                       %(<em><a href="#{encode_attr(ref["url"])}" target="_blank" rel="noopener">#{encode_html(title)}</a></em>)
+                     elsif type == "article" || type == "inproceedings"
+                       %("#{encode_html(title)}")
+                     else
+                       "<em>#{encode_html(title)}</em>"
+                     end
+        parts << title_html
+      end
+
+      case type
+      when "book"
+        parts << "#{encode_html(ref["edition"])}" if ref["edition"]
+        parts << encode_html(ref["publisher"]) if ref["publisher"]
+      when "article"
+        journal_parts = []
+        journal_parts << "<em>#{encode_html(ref["journal"])}</em>" if ref["journal"]
+        vol_num = []
+        vol_num << ref["volume"] if ref["volume"]
+        vol_num << "(#{ref["number"]})" if ref["number"]
+        journal_parts << vol_num.join("") unless vol_num.empty?
+        journal_parts << "pp. #{ref["pages"]}" if ref["pages"]
+        parts << journal_parts.join(", ") unless journal_parts.empty?
+      when "inproceedings"
+        conf_parts = []
+        conf_parts << "In <em>#{encode_html(ref["booktitle"])}</em>" if ref["booktitle"]
+        conf_parts << "pp. #{ref["pages"]}" if ref["pages"]
+        parts << conf_parts.join(", ") unless conf_parts.empty?
+      else
+        parts << encode_html(ref["publisher"]) if ref["publisher"]
+        parts << "<em>#{encode_html(ref["journal"])}</em>" if ref["journal"]
+        parts << "Vol. #{ref["volume"]}" if ref["volume"]
+        parts << "pp. #{ref["pages"]}" if ref["pages"]
+      end
+
+      parts << ref["year"].to_s if ref["year"]
+      parts << encode_html(ref["editor"]) if ref["editor"]
+      parts << encode_html(ref["note"]) if ref["note"]
+
+      # Strip trailing dots from parts to avoid double periods
+      html = parts.map { |p| p.sub(/\.\z/, "") }.join(". ") + "."
+
+      if ref["doi"] && !ref["url"]
+        doi_url = ref["doi"].start_with?("http") ? ref["doi"] : "https://doi.org/#{ref["doi"]}"
+        html += %( <a href="#{encode_attr(doi_url)}" target="_blank" rel="noopener">DOI</a>)
+      elsif ref["doi"] && ref["url"]
+        doi_url = ref["doi"].start_with?("http") ? ref["doi"] : "https://doi.org/#{ref["doi"]}"
+        html += %( <a href="#{encode_attr(doi_url)}" target="_blank" rel="noopener">DOI</a>)
+      end
+
+      html
+    end
+
+    def format_cite_label(ref)
+      author = ref["author"].to_s.split(/[,\s]/).first || "?"
+      year = ref["year"] ? ref["year"].to_s : "n.d."
+      "#{author}, #{year}"
+    end
+
+    def format_bib_hover(ref)
+      parts = []
+      parts << ref["author"] if ref["author"]
+      parts << ref["title"] if ref["title"]
+      parts << ref["publisher"] if ref["publisher"]
+      parts << ref["journal"] if ref["journal"]
+      parts << "Vol. #{ref["volume"]}" if ref["volume"]
+      parts << "No. #{ref["number"]}" if ref["number"]
+      parts << "pp. #{ref["pages"]}" if ref["pages"]
+      parts << ref["edition"] if ref["edition"]
+      parts << ref["year"].to_s if ref["year"]
+      parts << ref["note"] if ref["note"]
+      parts.join(". ") + "."
+    end
+
+    def encode_attr(text)
+      text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+    end
+
+    def encode_html(text)
+      text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+
     def copy_images
       images_dir = File.join(@config.base_dir, "images")
       return unless Dir.exist?(images_dir)

data/lib/ligarb/chapter.rb

@@ -7,11 +7,12 @@ module Ligarb
   class Chapter
     class CrossReferenceError < StandardError; end
 
-    attr_reader :title, :slug, :html, :headings, :number, :appendix_letter, :index_entries
+    attr_reader :title, :slug, :html, :headings, :number, :appendix_letter, :index_entries, :cite_entries
     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)
 
     def initialize(path, base_dir)
       @path     = path
@@ -63,7 +64,9 @@ module Ligarb
         target_path = File.expand_path(href_path, source_dir)
         entry = chapter_map[target_path]
         unless entry
-          raise CrossReferenceError, "cross-reference target not found: #{href_path} (from #{File.basename(@path)})"
+          line_no = @source.each_line.with_index(1) { |line, i| break i if line.include?(href_path) }
+          loc = line_no ? "#{@path}:#{line_no}" : File.basename(@path)
+          raise CrossReferenceError, "cross-reference target not found: #{href_path} (from #{loc})\n  link text: #{link_text.empty? ? "(auto)" : link_text}\n  resolved to: #{target_path}"
         end
 
         if fragment && !fragment.empty?
@@ -101,10 +104,13 @@ module Ligarb
       @html = rewrite_image_paths(doc.to_html)
       @html = apply_heading_ids(@html)
       @html = convert_special_code_blocks(@html)
+      @html = convert_inline_math(@html)
       @html = convert_admonitions(@html)
       @html = scope_footnote_ids(@html)
       @index_entries = []
       @html = extract_index_markers(@html)
+      @cite_entries = []
+      @html = extract_cite_markers(@html)
       @title = @headings.first&.text || @slug
     end
 
@@ -172,6 +178,24 @@ module Ligarb
       end
     end
 
+    def convert_inline_math(html)
+      # Protect <pre>...</pre> and <code>...</code> from conversion
+      placeholders = []
+      protected = html.gsub(%r{<(pre|code)([ >])(.*?)</\1>}m) do
+        placeholders << $&
+        "\x00PROTECT#{placeholders.size - 1}\x00"
+      end
+
+      # Convert $...$ to inline math (exclude $$, and $ followed/preceded by space)
+      result = protected.gsub(/(?<!\$)\$(?!\$)(?!\s)(.+?)(?<!\s)(?<!\$)\$(?!\$)/m) do
+        raw = decode_entities($1)
+        %(<span class="math-inline" data-math="#{encode_attr(raw)}"></span>)
+      end
+
+      # Restore protected parts
+      result.gsub(/\x00PROTECT(\d+)\x00/) { placeholders[$1.to_i] }
+    end
+
     def decode_entities(text)
       text.gsub("&amp;", "&").gsub("&lt;", "<").gsub("&gt;", ">").gsub("&quot;", '"').gsub("&#39;", "'")
     end
@@ -239,6 +263,25 @@ module Ligarb
       end
     end
 
+    def extract_cite_markers(html)
+      cite_count = 0
+      html.gsub(%r{<a\s+href="#cite:([^"]+)">(.*?)</a>}m) do
+        key = $1
+        display_text = $2
+        anchor_id = "#{@slug}--cite-#{cite_count}"
+        cite_count += 1
+
+        @cite_entries << CiteEntry.new(
+          key: key,
+          display_text: display_text,
+          chapter_slug: @slug,
+          anchor_id: anchor_id
+        )
+
+        %(<span id="#{anchor_id}" data-cite-key="#{key}">#{display_text}</span>)
+      end
+    end
+
     def rewrite_image_paths(html)
       html.gsub(/(<img\s[^>]*src=")([^"]+)(")/) do
         prefix = $1

data/lib/ligarb/claude_runner.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "cli"
+
+module Ligarb
+  class ClaudeRunner
+    PATCH_RE = %r{<patch(?:\s+file="([^"]*)")?>\s*<<<\n(.*?)\n===\n(.*?)\n>>>\s*</patch>}m
+
+    def initialize(config)
+      @config = config
+    end
+
+    def installed?
+      system("claude", "--version", out: File::NULL, err: File::NULL)
+    end
+
+    # Run claude -p with the given prompt. Returns the text response.
+    def run(prompt)
+      cmd = ["claude", "-p", "-", "--model", "opus", "--output-format", "json"]
+      stdout, stderr, status = Open3.capture3(*cmd, stdin_data: prompt)
+
+      unless status.success?
+        return { "error" => "Claude process failed: #{stderr.strip}" }
+      end
+
+      begin
+        result = JSON.parse(stdout)
+        text = result["result"] || stdout
+        { "text" => text }
+      rescue JSON::ParserError
+        { "text" => stdout.strip }
+      end
+    end
+
+    # Build prompt for reviewing a comment on selected text.
+    # Asks Claude to include <patch> blocks with concrete replacements.
+    # Points Claude to book.yml so it can read chapters and bibliography as needed.
+    def review_prompt(review)
+      ctx = review["context"]
+      source_file = ctx["source_file"]
+      config_path = File.join(@config.base_dir, "book.yml")
+
+      messages = review["messages"].map { |m| "#{m["role"]}: #{m["content"]}" }.join("\n\n")
+
+      uploaded_section = uploaded_files_prompt_section(ctx)
+
+      <<~PROMPT
+        You are reviewing a book built with ligarb.
+
+        <ligarb-spec>
+        #{CLI.spec_text}
+        </ligarb-spec>
+        #{uploaded_section}
+        Book configuration: #{config_path}
+        Read this file first to understand the book structure (chapters, bibliography, sources, etc.).
+        Then read the chapter files and other files as needed to respond to the comment.
+
+        The comment was made on: #{source_file}
+        The reader selected this text: "#{ctx["selected_text"]}"
+        Under heading: #{ctx["heading_id"]}
+
+        Conversation so far:
+        #{messages}
+
+        Respond to the reader's comment with a concise explanation, then provide
+        concrete patches. Each patch must use this exact format:
+
+        <patch file="relative/path/to/file.md">
+        <<<
+        exact text to find in the source (copied verbatim)
+        ===
+        replacement text
+        >>>
+        </patch>
+
+        Rules:
+        - The file attribute must be the path relative to the directory containing book.yml
+        - The text between <<< and === must match the source file EXACTLY (whitespace included)
+        - You may include multiple <patch> blocks for one or more files
+        - If the comment applies to multiple chapters, read all relevant chapters and provide patches for each
+        - When adding citations ([@key]), also add the corresponding entry to the bibliography file
+        - Use ligarb Markdown features (admonitions, cross-references, index, etc.) where appropriate
+        - If no code change is needed (e.g. answering a question), omit the <patch> blocks
+      PROMPT
+    end
+
+    # Extract patches from the last assistant message and apply them.
+    # Supports cross-chapter patches via the file attribute.
+    def apply_patches(review)
+      patches = extract_patches(review)
+      return { "error" => "No patches found in the conversation" } if patches.empty?
+
+      default_source = review.dig("context", "source_file")
+
+      # Group patches by target file
+      file_patches = {}
+      patches.each do |rel_path, old_text, new_text|
+        target = if rel_path && !rel_path.empty?
+                   resolve_patch_file(rel_path)
+                 else
+                   default_source
+                 end
+        next unless target
+
+        file_patches[target] ||= []
+        file_patches[target] << [old_text, new_text]
+      end
+
+      return { "error" => "No valid target files found for patches" } if file_patches.empty?
+
+      applied = 0
+      total = patches.size
+
+      file_patches.each do |file, file_patch_list|
+        unless File.exist?(file)
+          next
+        end
+
+        content = File.read(file)
+        changed = false
+
+        file_patch_list.each do |old_text, new_text|
+          if content.include?(old_text)
+            content = content.sub(old_text, new_text)
+            applied += 1
+            changed = true
+          end
+        end
+
+        File.write(file, content) if changed
+      end
+
+      return { "error" => "No patches matched the source files (0/#{total})" } if applied == 0
+
+      # Rebuild
+      config_path = File.join(@config.base_dir, "book.yml")
+      require_relative "builder"
+      begin
+        Builder.new(config_path).build
+      rescue SystemExit => e
+        return { "error" => "Applied #{applied}/#{total} patch(es) but rebuild failed: #{e.message}" }
+      end
+
+      { "text" => "Applied #{applied}/#{total} patch(es) and rebuilt." }
+    end
+
+    def uploaded_files_prompt_section(ctx)
+      files = ctx["uploaded_files"]
+      return "" unless files.is_a?(Array) && !files.empty?
+
+      lines = ["\nUploaded reference files (read these for context):"]
+      files.each do |f|
+        lines << "- #{f["label"]}: #{f["path"]}"
+      end
+      lines << ""
+      lines.join("\n")
+    end
+
+    # Parse <patch> blocks from assistant messages.
+    # Returns array of [file_path_or_nil, old_text, new_text].
+    def extract_patches(review)
+      (review["messages"] || [])
+        .select { |m| m["role"] == "assistant" }
+        .reverse
+        .each do |msg|
+          patches = msg["content"].scan(PATCH_RE)
+          return patches unless patches.empty?
+        end
+      []
+    end
+
+    private
+
+    # Resolve a relative path from a patch to an absolute path.
+    def resolve_patch_file(rel_path)
+      absolute = File.join(@config.base_dir, rel_path)
+      return absolute if File.exist?(absolute)
+
+      # Try matching by basename against all chapter paths
+      @config.all_file_paths.find { |p| p.end_with?("/#{rel_path}") || p == rel_path }
+    end
+  end
+end