ligarb 0.4.0 → 0.6.0

data/lib/ligarb/claude_runner.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require_relative "cli"
+
+module Ligarb
+  class ClaudeRunner
+    PATCH_RE = %r{<patch(?:\s+file="([^"]*)")?>\s*<<<[ \t]*\r?\n(.*?)\r?\n===[ \t]*\r?\n(.*?)\r?\n>>>[ \t]*\s*</patch>}m
+
+    def initialize(config)
+      @config = config
+    end
+
+    def installed?
+      claude_path = which("claude")
+      return :not_found unless claude_path
+
+      if system(claude_path, "--version", out: File::NULL, err: File::NULL)
+        true
+      else
+        :version_failed
+      end
+    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.
+    # Uses transactional approach: all patches applied in memory first,
+    # then written to disk. On build failure, changes are rolled back.
+    def apply_patches(review)
+      patches = extract_patches(review)
+      if patches.empty?
+        hint = has_unmatched_patches?(review) ? " (patch tags found but format didn't match)" : ""
+        return { "error" => "No patches found in the conversation#{hint}" }
+      end
+
+      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?
+
+      use_git = git_available?
+      target_files = file_patches.keys
+
+      # Check for uncommitted changes when git is available
+      if use_git
+        dirty = git_dirty_files(target_files)
+        unless dirty.empty?
+          return { "error" => "Cannot apply patches: uncommitted changes in #{dirty.join(", ")}" }
+        end
+      end
+
+      # Phase 1: Apply all patches in memory
+      applied = 0
+      total = patches.size
+      results = {} # file => new_content
+      backups = {} # file => original_content
+
+      file_patches.each do |file, file_patch_list|
+        next unless File.exist?(file)
+
+        content = File.read(file)
+        backups[file] = content
+
+        file_patch_list.each do |old_text, new_text|
+          if content.include?(old_text)
+            content = content.sub(old_text, new_text)
+            applied += 1
+          end
+        end
+
+        results[file] = content if content != backups[file]
+      end
+
+      return { "error" => "No patches matched the source files (0/#{total})" } if applied == 0
+
+      # Phase 2: Write all files at once
+      results.each { |file, content| File.write(file, content) }
+
+      # Phase 3: Rebuild
+      config_path = File.join(@config.base_dir, "book.yml")
+      require_relative "builder"
+      begin
+        Builder.new(config_path).build
+      rescue SystemExit => e
+        # Rollback on build failure
+        if use_git
+          git_rollback_files(results.keys)
+        else
+          backups.each { |file, content| File.write(file, content) if results.key?(file) }
+        end
+        return { "error" => "Applied #{applied}/#{total} patch(es) but rebuild failed (rolled back): #{e.message}" }
+      end
+
+      # Phase 4: Commit on success
+      if use_git
+        git_commit_patches(results.keys, review)
+      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
+
+    # Check if assistant messages contain <patch> tags that didn't match PATCH_RE.
+    def has_unmatched_patches?(review)
+      (review["messages"] || [])
+        .select { |m| m["role"] == "assistant" }
+        .any? { |m| m["content"].include?("<patch") && m["content"].include?("</patch>") }
+    end
+
+    # Check if git is available in the project directory.
+    def git_available?
+      system("git", "rev-parse", "--git-dir",
+             chdir: @config.base_dir, out: File::NULL, err: File::NULL)
+    end
+
+    private
+
+    # Return list of target files that have uncommitted changes.
+    def git_dirty_files(files)
+      files.select do |file|
+        rel = relative_to_base(file)
+        next false unless rel
+        out, = Open3.capture2("git", "status", "--porcelain", "--", rel, chdir: @config.base_dir)
+        !out.strip.empty?
+      end
+    end
+
+    # Commit patched files with a message including review context.
+    def git_commit_patches(files, review)
+      rel_files = files.filter_map { |f| relative_to_base(f) }
+      return if rel_files.empty?
+
+      system("git", "add", "--", *rel_files, chdir: @config.base_dir)
+
+      message = build_commit_message(review, rel_files)
+      system("git", "commit", "-m", message, chdir: @config.base_dir,
+             out: File::NULL, err: File::NULL)
+    end
+
+    # Rollback files using git checkout.
+    def git_rollback_files(files)
+      rel_files = files.filter_map { |f| relative_to_base(f) }
+      return if rel_files.empty?
+
+      system("git", "checkout", "--", *rel_files, chdir: @config.base_dir,
+             out: File::NULL, err: File::NULL)
+    end
+
+    def build_commit_message(review, rel_files)
+      messages = review["messages"] || []
+      user_msg = messages.find { |m| m["role"] == "user" }&.dig("content").to_s
+      assistant_msg = messages.select { |m| m["role"] == "assistant" }.last&.dig("content").to_s
+
+      source = review.dig("context", "source_file") || "unknown"
+      source_rel = relative_to_base(source) || source
+
+      lines = ["[ligarb] Review: #{source_rel}"]
+      lines << ""
+      lines << "User: #{truncate_message(user_msg)}" unless user_msg.empty?
+      lines << "Claude: #{truncate_message(assistant_msg)}" unless assistant_msg.empty?
+      lines << ""
+      lines << "Files: #{rel_files.join(", ")}"
+      lines.join("\n")
+    end
+
+    def truncate_message(text, max_lines: 3, max_chars: 200)
+      truncated = text.lines.first(max_lines).join.strip
+      truncated = truncated[0, max_chars] + "..." if truncated.length > max_chars
+      truncated
+    end
+
+    def relative_to_base(file)
+      abs = File.expand_path(file)
+      base = File.expand_path(@config.base_dir)
+      return nil unless abs.start_with?(base + "/")
+      abs[(base.length + 1)..]
+    end
+
+    def which(cmd)
+      ENV["PATH"].to_s.split(File::PATH_SEPARATOR).each do |dir|
+        path = File.join(dir, cmd)
+        return path if File.executable?(path)
+      end
+      nil
+    end
+
+    # Resolve a relative path from a patch to an absolute path.
+    # Prevents path traversal outside base_dir.
+    def resolve_patch_file(rel_path)
+      absolute = File.expand_path(rel_path, @config.base_dir)
+      base_dir = File.expand_path(@config.base_dir)
+
+      # Reject paths that escape base_dir (e.g. "../../etc/passwd")
+      unless absolute.start_with?(base_dir + "/")
+        $stderr.puts "Warning: patch path '#{rel_path}' resolves outside project directory, skipping"
+        return nil
+      end
+
+      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

data/lib/ligarb/cli.rb

@@ -17,15 +17,36 @@ 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
+        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
+      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)
+        require_relative "server"
+        Server.new(config_paths, port: port, multi: true).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 +68,8 @@ 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 librarium       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)
@@ -109,6 +132,38 @@ 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)
+                                  --multi      Force multi-book mode (even with 1 CONFIG)
+                                Single book mode (1 CONFIG, without --multi):
+                                - Serves the built HTML book at http://localhost:PORT
+                                Multi-book mode (2+ CONFIGs, or --multi):
+                                - 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 librarium        Start a multi-book library server.
+                                Automatically discovers */book.yml in the current directory.
+                                Equivalent to: ligarb serve --multi */book.yml
+                                Options:
+                                  --port PORT  Server port (default: 3000)
+
         ligarb help             Show this detailed specification.
 
         ligarb --help           Show short usage summary.
@@ -255,9 +310,11 @@ module Ligarb
         and build/css/.
 
         ```ruby, ```python, etc.   Syntax highlighting (highlight.js, BSD-3-Clause)
-        ```mermaid                  Diagrams: flowcharts, sequence, class, etc.
+        ```mermaid                  Diagrams: flowcharts, sequence, bar/line/pie charts,
+                                    gantt, mindmap, etc.
                                     (mermaid, MIT)
         ```math                     LaTeX math equations (KaTeX, MIT)
+        ```functionplot             Function graphs (function-plot + d3, MIT)
 
         These are rendered visually in the output HTML — use them freely.
 
@@ -278,6 +335,64 @@ module Ligarb
                 Server-->>Client: Response
             ```
 
+        Mermaid example (bar chart):
+
+            ```mermaid
+            xychart
+                title "Monthly Sales"
+                x-axis ["Jan", "Feb", "Mar", "Apr", "May"]
+                y-axis "Revenue" 0 --> 500
+                bar [120, 230, 180, 350, 410]
+                line [120, 230, 180, 350, 410]
+            ```
+
+        Mermaid example (line chart, line only):
+
+            ```mermaid
+            xychart
+                title "Temperature"
+                x-axis ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
+                y-axis "°C" -5 --> 30
+                line [2, 4, 10, 16, 22, 26]
+            ```
+
+        Mermaid example (pie chart):
+
+            ```mermaid
+            pie title Browser Share
+                "Chrome" : 65
+                "Safari" : 19
+                "Firefox" : 4
+                "Other" : 12
+            ```
+
+        Mermaid example (gantt chart):
+
+            ```mermaid
+            gantt
+                title Project Plan
+                dateFormat YYYY-MM-DD
+                section Design
+                    Requirements :a1, 2025-01-01, 14d
+                    Architecture :a2, after a1, 10d
+                section Dev
+                    Implementation :b1, after a2, 21d
+                    Testing        :b2, after b1, 14d
+            ```
+
+        Mermaid example (mindmap):
+
+            ```mermaid
+            mindmap
+                root((Project))
+                    Frontend
+                        React
+                        CSS
+                    Backend
+                        API
+                        Database
+            ```
+
         Math example (KaTeX, LaTeX syntax):
 
             ```math
@@ -295,6 +410,28 @@ module Ligarb
         - Content inside <code> and <pre> is not affected
         - The content is rendered with KaTeX (displayMode: false)
 
+        Function plot example:
+
+            ```functionplot
+            y = sin(x)
+            y = x^2 - 1
+            range: [-2pi, 2pi]
+            yrange: [-3, 3]
+            ```
+
+        Function plot syntax:
+        - y = <expr>                   Standard function (e.g. y = sin(x))
+        - r = <expr>                   Polar function (e.g. r = cos(2*theta))
+        - parametric: <x>, <y>         Parametric curve (e.g. parametric: cos(t), sin(t))
+        - Bare expression              Treated as y = <expr>
+        Options (one per line):
+        - range / xrange: [min, max]   X-axis range (supports pi, e.g. [-2pi, 2pi])
+        - yrange: [min, max]           Y-axis range
+        - width: <pixels>              Plot width (default: 600)
+        - height: <pixels>             Plot height (default: 400)
+        - title: <text>                Plot title
+        - grid: true                   Show grid lines
+
         == Images ==
 
         Place image files in the 'images/' directory next to book.yml.
@@ -344,6 +481,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/initializer.rb

@@ -34,6 +34,7 @@ module Ligarb
       File.write(book_yml, generate_book_yml(title, chapter_paths))
       File.write(File.join(target, "images", ".gitkeep"), "")
 
+      init_git(target)
       print_success(target, chapter_paths)
     end
 
@@ -86,6 +87,25 @@ module Ligarb
       puts "  Run 'ligarb build' to generate HTML"
     end
 
+    def init_git(target)
+      unless system("git", "rev-parse", "--git-dir", out: File::NULL, err: File::NULL, chdir: target)
+        write_gitignore(target)
+        system("git", "init", chdir: target)
+        puts "Initialized git repository"
+      end
+    end
+
+    def write_gitignore(target)
+      gitignore = File.join(target, ".gitignore")
+      return if File.exist?(gitignore)
+
+      File.write(gitignore, <<~IGNORE)
+        # Generated by ligarb - remove lines as needed
+        build/
+        .ligarb/
+      IGNORE
+    end
+
     def relative_path(target)
       if @directory && @directory != "."
         @directory.start_with?("/") ? @directory : "./#{@directory}"