ligarb 0.5.0 → 0.7.0

data/lib/ligarb/claude_runner.rb

@@ -6,14 +6,21 @@ require_relative "cli"
 
 module Ligarb
   class ClaudeRunner
-    PATCH_RE = %r{<patch(?:\s+file="([^"]*)")?>\s*<<<\n(.*?)\n===\n(.*?)\n>>>\s*</patch>}m
+    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?
-      system("claude", "--version", out: File::NULL, err: File::NULL)
+      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.
@@ -88,9 +95,14 @@ module Ligarb
 
     # 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)
-      return { "error" => "No patches found in the conversation" } if patches.empty?
+      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")
 
@@ -110,37 +122,62 @@ module Ligarb
 
       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|
-        unless File.exist?(file)
-          next
-        end
+        next unless File.exist?(file)
 
         content = File.read(file)
-        changed = false
+        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
-            changed = true
           end
         end
 
-        File.write(file, content) if changed
+        results[file] = content if content != backups[file]
       end
 
       return { "error" => "No patches matched the source files (0/#{total})" } if applied == 0
 
-      # Rebuild
+      # 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
-        return { "error" => "Applied #{applied}/#{total} patch(es) but rebuild failed: #{e.message}" }
+        # 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." }
@@ -171,11 +208,102 @@ module Ligarb
       []
     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.join(@config.base_dir, 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

data/lib/ligarb/cli.rb

@@ -22,8 +22,18 @@ module Ligarb
         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).start
+        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"
         require_relative "writer"
         begin
@@ -59,6 +69,7 @@ module Ligarb
           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)
@@ -79,6 +90,7 @@ module Ligarb
           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
+          translations     (optional) Map of lang => config path for multi-language builds
 
         Example:
           ligarb build
@@ -127,9 +139,10 @@ module Ligarb
                                 Multiple CONFIG paths can be given to serve multiple books.
                                 Options:
                                   --port PORT  Server port (default: 3000)
-                                Single book mode (1 CONFIG):
+                                  --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):
+                                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
@@ -146,6 +159,12 @@ module Ligarb
                                 - 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.
@@ -176,8 +195,10 @@ module Ligarb
         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.
+        translations:    (optional) A mapping of language codes to config file paths.
+                         Enables multi-language support. See "Translations" section below.
         chapters:        (required) Book structure. An array that can contain:
-                         - A cover: a centered title/landing page
+                         - A cover: the landing page shown when the book is opened
                          - A string: a chapter Markdown file path (relative to book.yml)
                          - A part: groups chapters under a titled section
                          - An appendix: groups chapters with alphabetic numbering (A, B, C, ...)
@@ -186,7 +207,7 @@ module Ligarb
 
         1. Cover (object with 'cover' key):
                chapters:
-                 - cover: cover.md          # Markdown file: displayed as centered title page
+                 - cover: cover.md          # Markdown file: landing page shown when the book is opened
                                             # Not shown in the TOC sidebar.
 
         2. Plain chapter (string):
@@ -292,9 +313,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.
 
@@ -315,6 +338,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
@@ -332,6 +413,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.
@@ -558,6 +661,8 @@ module Ligarb
         language:        (optional) Language. Default: "ja".
         audience:        (optional) Target audience (used in the prompt).
         notes:           (optional) Additional instructions for Claude (free text).
+        sources:         (optional) Reference files for AI context. Array of strings
+                         or {path:, label:} objects. Paths relative to brief.yml.
         author:          (optional) Passed through to book.yml.
         output_dir:      (optional) Passed through to book.yml.
         chapter_numbers: (optional) Passed through to book.yml.
@@ -568,6 +673,56 @@ module Ligarb
         Example: 'ligarb write ruby_book/brief.yml' creates files in ruby_book/.
 
         Requires the 'claude' CLI to be installed.
+
+        == Translations (Multi-Language) ==
+
+        ligarb supports building the same book in multiple languages. A parent
+        config file (hub) defines shared settings and points to per-language
+        config files.
+
+        Hub config (book.yml):
+
+            repository: "https://github.com/user/repo"
+            ai_generated: true
+            translations:
+              ja: book.ja.yml
+              en: book.en.yml
+
+        Per-language config (book.ja.yml):
+
+            title: "マニュアル"
+            language: "ja"
+            chapters:
+              - chapters/ja/01-intro.md
+
+        Per-language config (book.en.yml):
+
+            title: "Manual"
+            language: "en"
+            chapters:
+              - chapters/en/01-intro.md
+
+        Building the hub builds all translations:
+
+            ligarb build book.yml        # Builds all languages
+            ligarb build book.ja.yml     # Builds only Japanese (standalone)
+
+        Inheritance rules:
+        - The hub's settings (repository, style, ai_generated, etc.) are
+          inherited by each per-language config as defaults.
+        - Per-language configs can override any inherited setting.
+        - title, language, and chapters are always per-language (required in
+          each per-language config).
+
+        The hub config does not need 'title' or 'chapters' fields — it only
+        needs 'translations'. If the hub has no 'chapters', it is treated
+        purely as a translations hub.
+
+        Language switcher:
+        - When built via the hub, each output HTML includes a language switcher
+          in the sidebar header (e.g. [JA | EN]).
+        - Links use relative paths between output directories.
+        - The current language is highlighted; others are clickable links.
       SPEC
     end
 

data/lib/ligarb/config.rb

@@ -6,20 +6,56 @@ module Ligarb
   class Config
     REQUIRED_KEYS = %w[title chapters].freeze
 
+    # Keys that can be inherited from a parent (translations hub) config.
+    # output_dir is intentionally excluded — it always comes from the
+    # config file that was directly passed to `ligarb build`.
+    INHERITABLE_KEYS = %w[author language chapter_numbers style
+                          repository ai_generated footer bibliography].freeze
+
     # Represents a structural entry in the book
     StructEntry = Struct.new(:type, :path, :children, keyword_init: true)
     # type: :chapter, :part, or :appendix_group
     # path: markdown file path (for :chapter and :part), nil for :appendix_group
     # children: array of StructEntry (for :part and :appendix_group)
 
+    # Represents a translation entry
+    # output_path: absolute path to the translation's build directory (for link generation)
+    TranslationEntry = Struct.new(:lang, :config_path, :title, :language, :output_path, keyword_init: true)
+
     attr_reader :title, :author, :language, :output_dir, :base_dir,
                 :chapter_numbers, :structure, :style, :repository,
-                :ai_generated, :footer, :bibliography, :sources
+                :ai_generated, :footer, :bibliography, :sources,
+                :translations
 
-    def initialize(path)
+    def initialize(path, parent_data: nil)
       @base_dir = File.dirname(File.expand_path(path))
       data = YAML.safe_load_file(path)
 
+      # If this is a translations hub (has translations but no chapters), skip normal validation
+      if data.is_a?(Hash) && data.key?("translations") && !data.key?("chapters")
+        @translations_hub = true
+        @translations_data = data
+        load_translations_hub(data)
+        return
+      end
+
+      # Load inherit file if specified (for standalone builds of child configs)
+      if !parent_data && data.is_a?(Hash) && data.key?("inherit")
+        inherit_path = File.expand_path(data["inherit"], @base_dir)
+        if File.exist?(inherit_path)
+          parent_data = YAML.safe_load_file(inherit_path)
+        else
+          abort "Error: inherit config not found: #{inherit_path}"
+        end
+      end
+
+      # Merge parent (inheritable) keys as defaults
+      if parent_data
+        INHERITABLE_KEYS.each do |key|
+          data[key] = parent_data[key] if parent_data.key?(key) && !data.key?(key)
+        end
+      end
+
       validate!(data)
 
       @title           = data["title"]
@@ -34,6 +70,13 @@ module Ligarb
       @bibliography    = data.fetch("bibliography", nil)
       @sources         = parse_sources(data.fetch("sources", []))
       @structure       = parse_structure(data["chapters"])
+      @translations    = []
+
+      load_translations(data, path) if data.key?("translations")
+    end
+
+    def translations_hub?
+      @translations_hub == true
     end
 
     def output_path
@@ -137,6 +180,66 @@ module Ligarb
       collect_chapter_paths(entries)
     end
 
+    def load_translations(data, config_path)
+      trans = data["translations"]
+      return unless trans.is_a?(Hash)
+
+      trans.each do |lang, rel_path|
+        abs_path = File.expand_path(rel_path, @base_dir)
+        unless File.exist?(abs_path)
+          abort "Error: translation config not found: #{abs_path}"
+        end
+        child_data = YAML.safe_load_file(abs_path)
+        # Merge parent keys for output_dir resolution
+        INHERITABLE_KEYS.each do |key|
+          child_data[key] = data[key] if data.key?(key) && !child_data.key?(key)
+        end
+        child_title = child_data["title"] || @title
+        child_lang = child_data.fetch("language", lang)
+        child_base = File.dirname(abs_path)
+        child_output = File.join(child_base, child_data.fetch("output_dir", "build"))
+        @translations << TranslationEntry.new(
+          lang: lang,
+          config_path: abs_path,
+          title: child_title,
+          language: child_lang,
+          output_path: child_output
+        )
+      end
+    end
+
+    def load_translations_hub(data)
+      @title = data.fetch("title", "")
+      @translations = []
+
+      trans = data["translations"]
+      return unless trans.is_a?(Hash)
+
+      trans.each do |lang, rel_path|
+        abs_path = File.expand_path(rel_path, @base_dir)
+        unless File.exist?(abs_path)
+          abort "Error: translation config not found: #{abs_path}"
+        end
+        child_data = YAML.safe_load_file(abs_path)
+        # Merge inheritable keys from hub as defaults
+        merged = child_data.dup
+        INHERITABLE_KEYS.each do |key|
+          merged[key] = data[key] if data.key?(key) && !merged.key?(key)
+        end
+        child_title = merged["title"] || @title
+        child_lang = merged.fetch("language", lang)
+        child_base = File.dirname(abs_path)
+        child_output = File.join(child_base, merged.fetch("output_dir", "build"))
+        @translations << TranslationEntry.new(
+          lang: lang,
+          config_path: abs_path,
+          title: child_title,
+          language: child_lang,
+          output_path: child_output
+        )
+      end
+    end
+
     def validate!(data)
       unless data.is_a?(Hash)
         abort "Error: book.yml must be a YAML mapping"

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}"