sakusei 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d842e81bb78fb5e34d0750ee5f125b13b6a7b5dec236ce70547fcb44e6438ca
+  data.tar.gz: 6872dbd65f839bd5e3fb786bcbf8712310c03aa99332f6ff740901fc26275800
+SHA512:
+  metadata.gz: 96c3e6db1059839c6bd8632c11789dfd6ec56af507b8f6ef754600dcee498be62fbad33b605cde5853fdb4734150a88ce53ba1bef863df09bf89e23c93c6e1c3
+  data.tar.gz: a784a67e5c4cfbda815f3f6b96c0cc2de177125ce42bf7cc941a27a901487bb5f67a04240530e0f94ee1cf31500b402d650dc3298765ddae8e19b6a88a46152e

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.DS_Store
+*.pdf
+node_modules/

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sakusei.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'

data/README.md

@@ -0,0 +1,191 @@
+# Sakusei
+
+**Sakusei** (作成) — from the Japanese words meaning "creation," "making," or "craft."
+
+Like a master artisan refining their craft, Sakusei transforms raw Markdown into beautifully crafted PDF documents. Every document is an act of creation — structured, styled, and brought to life with precision.
+
+The name embodies the philosophy behind this tool: documents aren't just generated, they're _crafted_.
+
+
+## Overview
+
+Sakusei is a build system for creating PDF documents from Markdown source files. It supports:
+
+- **Markdown to PDF conversion** via `md-to-pdf`
+- **ERB template evaluation** for dynamic content
+- **Hierarchical style packs** for consistent document styling
+- **File inclusion** for multi-file documents
+- **PDF concatenation** for combining multiple documents
+
+
+## Installation
+
+### macOS (Homebrew)
+
+```bash
+# Add the tap and install
+brew tap keithrowell/sakusei https://github.com/keithrowell/sakusei/homebrew-tap
+brew install sakusei
+```
+
+### Ruby Gem
+
+```bash
+gem install sakusei
+```
+
+### Build from Source
+
+```bash
+git clone https://github.com/keithrowell/sakusei
+cd sakusei
+bundle install
+rake install
+```
+
+**Prerequisites:**
+- Ruby 3.0+
+- Node.js (for md-to-pdf)
+- pdfunite or pdftk (for PDF concatenation)
+
+## Quick Start
+
+### Build a PDF from Markdown
+
+```bash
+sakusei build document.md
+```
+
+Or simply (build is the default command):
+
+```bash
+sakusei document.md
+```
+
+Extension is optional - `.md`, `.text`, or `.markdown` will be tried:
+
+```bash
+sakusei document    # Looks for document.md, document.text, or document.markdown
+```
+
+Auto-open after building:
+
+```bash
+sakusei document.md --open
+```
+
+### Initialize a Style Pack
+
+```bash
+sakusei init my_company
+```
+
+### Concatenate PDFs
+
+```bash
+sakusei concat part1.pdf part2.pdf -o combined.pdf
+```
+
+## Style Packs
+
+Style packs are stored in `.sakusei/style_packs/` directories. Sakusei searches for style packs by walking up the directory tree from your source file.
+
+```
+.sakusei/
+└── style_packs/
+    └── my_company/
+        ├── config.js      # md-to-pdf configuration
+        ├── style.css      # Stylesheet
+        ├── header.html    # Header template
+        └── footer.html    # Footer template
+```
+
+## File Inclusion
+
+Include other markdown files in your document:
+
+```markdown
+# My Document
+
+<!-- @include ./introduction.md -->
+
+<!-- @include ./chapter1.md -->
+```
+
+## ERB Templates
+
+Use ERB for dynamic content:
+
+```markdown
+# Report Generated <%= today %>
+
+Environment: <%= env('RAILS_ENV', 'development') %>
+```
+
+## Page Breaks
+
+### Manual Page Breaks
+
+Insert page breaks in your markdown using HTML:
+
+```markdown
+# Chapter 1
+
+Content here...
+
+<div class="page-break"></div>
+
+# Chapter 2
+
+More content...
+```
+
+Available classes:
+- `.page-break` or `.page-break-after` - Break after this element
+- `.page-break-before` - Break before this element
+
+### Automatic Keep-Together
+
+The base stylesheet automatically prevents page breaks inside these elements:
+- Tables (including rows)
+- Code blocks (`<pre>`)
+- Blockquotes
+- Images
+- Figures and captions
+- Definition lists (`<dl>`, `<dt>`, `<dd>`)
+- Details/summary sections
+- Math blocks (KaTeX)
+- Custom elements: `.admonition`, `.callout`, `.card`, `.box`
+
+To force keep-together on any element, add the `.keep-together` class:
+
+```markdown
+<div class="keep-together">
+
+This content will not be split across pages.
+
+| Table | Data |
+|-------|------|
+| A     | 1    |
+| B     | 2    |
+
+</div>
+```
+
+## Build Scripts
+
+Create a `.sakusei_build` file for complex builds:
+
+```yaml
+steps:
+  - command: build
+    files:
+      - cover.md
+      - content/*.md
+    output: document.pdf
+    style: my_company
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb', 'test/**/*_test.rb']
+  t.verbose = true
+end
+
+task default: :test

data/bin/sakusei

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'sakusei'
+
+Sakusei::CLI.start(ARGV)

data/lib/sakusei/builder.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'style_pack'
+require_relative 'file_resolver'
+require_relative 'erb_processor'
+require_relative 'vue_processor'
+require_relative 'md_to_pdf_converter'
+
+module Sakusei
+  class Builder
+    def initialize(source_file, options = {})
+      @source_file = File.expand_path(source_file)
+      @options = options
+      @source_dir = File.dirname(@source_file)
+    end
+
+    def build
+      # 1. Discover and load style pack
+      style_pack = discover_style_pack
+
+      # 2. Resolve and concatenate file references
+      resolved_content = resolve_files
+
+      # 3. Process ERB templates
+      processed_content = process_erb(resolved_content)
+
+      # 4. Process Vue components (if available)
+      processed_content = process_vue(processed_content)
+
+      # 5. Convert to PDF
+      output_path = generate_output_path
+      convert_to_pdf(processed_content, output_path, style_pack)
+
+      output_path
+    end
+
+    private
+
+    def discover_style_pack
+      StylePack.discover(@source_dir, @options[:style])
+    end
+
+    def resolve_files
+      FileResolver.new(@source_file).resolve
+    end
+
+    def process_erb(content)
+      ErbProcessor.new(content, @source_dir).process
+    end
+
+    def process_vue(content)
+      VueProcessor.new(content, @source_dir).process
+    end
+
+    def convert_to_pdf(content, output_path, style_pack)
+      MdToPdfConverter.new(content, output_path, style_pack, @options).convert
+    end
+
+    def generate_output_path
+      return File.expand_path(@options[:output]) if @options[:output]
+
+      base_name = File.basename(@source_file, '.*')
+      File.join(@source_dir, "#{base_name}.pdf")
+    end
+  end
+end

data/lib/sakusei/cli.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Sakusei
+  class CLI < Thor
+    desc 'preview [STYLE]', 'Generate a preview PDF showing all style elements'
+    option :output, aliases: '-o', default: 'style-preview.pdf', desc: 'Output PDF file path'
+    option :config, aliases: '-c', desc: 'Path to md-to-pdf config file'
+    option :stylesheet, aliases: '-css', desc: 'Path to CSS stylesheet'
+    def preview(style = nil)
+      preview = StylePreview.new(style, options)
+      output_path = preview.generate
+      say "Style preview generated: #{output_path}", :green
+    rescue Error => e
+      say_error e.message
+      exit 1
+    end
+
+    desc 'build FILES', 'Build PDF from markdown FILE(s). Accepts multiple files, globs, or directories.'
+    option :output, aliases: '-o', desc: 'Output PDF file path'
+    option :style, aliases: '-s', desc: 'Style pack name to use'
+    option :config, aliases: '-c', desc: 'Path to md-to-pdf config file'
+    option :stylesheet, aliases: '-css', desc: 'Path to CSS stylesheet'
+    option :page_breaks, aliases: '-p', type: :boolean, default: false, desc: 'Add page breaks between files'
+    option :open, type: :boolean, default: false, desc: 'Open the PDF after building'
+    def build(*files)
+      raise Error, 'No input files provided' if files.empty?
+
+      # Resolve file extensions (.md, .text, .markdown) if not provided
+      resolved_files = files.map { |f| resolve_file_extension(f) }
+
+      # Check if we have multiple files, globs, or directories
+      if resolved_files.length > 1 || resolved_files.any? { |f| f.include?('*') || File.directory?(f) }
+        # Multi-file build
+        builder = MultiFileBuilder.new(resolved_files, options)
+      else
+        # Single file build
+        raise Error, "File not found: #{resolved_files.first}" unless File.exist?(resolved_files.first)
+        builder = Builder.new(resolved_files.first, options)
+      end
+
+      output_path = builder.build
+      say "PDF created: #{output_path}", :green
+
+      # Open the PDF if requested
+      open_pdf(output_path) if options[:open]
+    rescue Error => e
+      say_error e.message
+      exit 1
+    end
+
+    desc 'init [NAME]', 'Initialize a new style pack'
+    option :directory, aliases: '-d', default: '.', desc: 'Directory to create style pack in'
+    def init(name = 'default')
+      StylePackInitializer.new(options[:directory], name).run
+      say "Style pack '#{name}' created in #{options[:directory]}/.sakusei/style_packs/#{name}", :green
+    rescue Error => e
+      say_error e.message
+      exit 1
+    end
+
+    desc 'concat FILES', 'Concatenate multiple PDF files'
+    option :output, aliases: '-o', required: true, desc: 'Output PDF file path'
+    def concat(*files)
+      raise Error, 'No input files provided' if files.empty?
+
+      PdfConcat.new(files, options[:output]).concat
+      say "PDFs concatenated: #{options[:output]}", :green
+    rescue Error => e
+      say_error e.message
+      exit 1
+    end
+
+    desc 'styles', 'List available style packs'
+    option :directory, aliases: '-d', default: '.', desc: 'Directory to search for style packs'
+    def styles
+      style_packs = StylePack.list_available(options[:directory])
+
+      if style_packs.empty?
+        say 'No style packs found.', :yellow
+        say "Run 'sakusei init <name>' to create a new style pack."
+      else
+        say 'Available style packs:', :green
+        style_packs.each do |pack|
+          say "  • #{pack[:name]}"
+          say "    Path: #{pack[:path]}", :cyan
+        end
+      end
+    rescue Error => e
+      say_error e.message
+      exit 1
+    end
+
+    desc 'version', 'Show version'
+    def version
+      say "Sakusei #{Sakusei::VERSION}"
+    end
+    map %w[--version -v] => :version
+
+    default_task :help
+
+    # Override dispatch to treat file paths as build commands
+    def self.dispatch(meth, given_args, given_opts, config)
+      # If first arg is an existing file or glob pattern, treat it as a build command
+      if given_args.any? && file_arg?(given_args.first)
+        given_args.unshift('build')
+      end
+      super
+    end
+
+    def self.file_arg?(arg)
+      return false if arg.nil?
+      return false if arg.start_with?('-')  # Skip options
+
+      # Check if it's a file (with or without extension), glob pattern, or directory
+      File.exist?(arg) || file_with_extension?(arg) || arg.include?('*') || File.directory?(arg)
+    end
+
+    # Check if file exists with any of the supported markdown extensions
+    def self.file_with_extension?(arg)
+      return false if arg.nil? || arg.empty?
+      return false if File.extname(arg).length > 0  # Already has an extension
+
+      %w[.md .text .markdown].any? { |ext| File.exist?(arg + ext) }
+    end
+
+    private
+
+    # Resolve file by trying markdown extensions if no extension provided
+    def resolve_file_extension(file)
+      return file if File.exist?(file)
+      return file if File.directory?(file)
+      return file if file.include?('*')  # Glob pattern
+      return file if File.extname(file).length > 0  # Already has extension
+
+      # Try markdown extensions
+      %w[.md .text .markdown].each do |ext|
+        path_with_ext = file + ext
+        return path_with_ext if File.exist?(path_with_ext)
+      end
+
+      # Return original if no extension found
+      file
+    end
+
+    def open_pdf(path)
+      return unless File.exist?(path)
+
+      cmd = case RbConfig::CONFIG['host_os']
+            when /darwin/i  # macOS
+              ['open', path]
+            when /linux/i
+              ['xdg-open', path]
+            when /mswin|mingw|cygwin/i  # Windows
+              ['start', path]
+            else
+              say "PDF created at: #{path}", :yellow
+              return
+            end
+
+      system(*cmd)
+    rescue => e
+      say_error "Failed to open PDF: #{e.message}"
+    end
+  end
+end

data/lib/sakusei/erb_processor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Sakusei
+  # Processes ERB templates in markdown content
+  class ErbProcessor
+    def initialize(content, base_dir)
+      @content = content
+      @base_dir = base_dir
+    end
+
+    def process
+      # Create a context object with helper methods
+      context = ErbContext.new(@base_dir)
+
+      # Process the ERB
+      erb = ERB.new(@content, trim_mode: '-')
+      erb.result(context.binding)
+    rescue StandardError => e
+      raise Error, "ERB processing error: #{e.message}"
+    end
+
+    # Context object that provides helper methods for ERB templates
+    class ErbContext
+      def initialize(base_dir)
+        @base_dir = base_dir
+      end
+
+      def binding
+        ::Kernel.binding
+      end
+
+      # Helper method to include file content directly
+      def include_file(path)
+        full_path = File.expand_path(path, @base_dir)
+        File.exist?(full_path) ? File.read(full_path) : "<!-- File not found: #{path} -->"
+      end
+
+      # Helper for current date
+      def today(format = '%Y-%m-%d')
+        Date.today.strftime(format)
+      end
+
+      # Helper for reading environment variables
+      def env(name, default = nil)
+        ENV.fetch(name, default)
+      end
+
+      # Helper for executing shell commands
+      def sh(command)
+        `#{command}`.chomp
+      end
+    end
+  end
+end

data/lib/sakusei/file_resolver.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Sakusei
+  # Resolves file references in markdown and concatenates them
+  class FileResolver
+    INCLUDE_PATTERN = /<!--\s*@include\s+(\S+)\s*-->/
+
+    def initialize(source_file)
+      @source_file = source_file
+      @source_dir = File.dirname(source_file)
+      @resolved_files = Set.new
+    end
+
+    def resolve
+      content = File.read(@source_file)
+      resolve_includes(content, @source_file)
+    end
+
+    private
+
+    def resolve_includes(content, parent_file)
+      content.gsub(INCLUDE_PATTERN) do |match|
+        file_ref = Regexp.last_match(1)
+        resolved_path = resolve_path(file_ref, parent_file)
+
+        next match unless resolved_path
+        next '' if @resolved_files.include?(resolved_path)
+
+        @resolved_files.add(resolved_path)
+
+        file_content = File.read(resolved_path)
+        # Recursively resolve includes in the included file
+        resolve_includes(file_content, resolved_path)
+      end
+    end
+
+    def resolve_path(file_ref, parent_file)
+      # Handle absolute paths
+      if file_ref.start_with?('/')
+        return File.exist?(file_ref) ? file_ref : nil
+      end
+
+      # Handle relative paths from the parent file's directory
+      parent_dir = File.dirname(parent_file)
+      full_path = File.expand_path(file_ref, parent_dir)
+
+      return full_path if File.exist?(full_path)
+
+      # Try with .md extension
+      full_path_with_ext = "#{full_path}.md"
+      return full_path_with_ext if File.exist?(full_path_with_ext)
+
+      nil
+    end
+  end
+end

data/lib/sakusei/md_to_pdf_converter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module Sakusei
+  # Converts markdown content to PDF using md-to-pdf
+  class MdToPdfConverter
+    def initialize(content, output_path, style_pack, options = {})
+      @content = content
+      @output_path = output_path
+      @style_pack = style_pack
+      @options = options
+    end
+
+    def convert
+      # Create temp directory for working files
+      Dir.mktmpdir('sakusei') do |temp_dir|
+        # Write content to temp markdown file
+        temp_md = File.join(temp_dir, 'input.md')
+        File.write(temp_md, @content)
+
+        # Build md-to-pdf command
+        cmd = build_command(temp_md, temp_dir)
+
+        # Execute command
+        result = system(cmd)
+        raise Error, 'PDF conversion failed' unless result
+
+        # md-to-pdf outputs to input.pdf in the same directory
+        temp_pdf = File.join(temp_dir, 'input.pdf')
+
+        # Move to final destination
+        FileUtils.mv(temp_pdf, @output_path)
+      end
+
+      @output_path
+    end
+
+    private
+
+    def build_command(temp_path, temp_dir)
+      cmd = ['npx', 'md-to-pdf']
+
+      # Config file
+      config = @options[:config] || @style_pack.config
+      cmd << '--config-file' << config if config
+
+      # Stylesheets - base CSS first, then style pack CSS
+      # This allows style packs to override base styles
+      stylesheets = [StylePack.base_stylesheet]
+
+      # Add style pack stylesheet if available
+      pack_stylesheet = @options[:stylesheet] || @style_pack.stylesheet
+      stylesheets << pack_stylesheet if pack_stylesheet
+
+      stylesheets.each do |stylesheet|
+        cmd << '--stylesheet' << stylesheet
+      end
+
+      # Basedir for resolving relative paths
+      cmd << '--basedir' << temp_dir
+
+      # Input file
+      cmd << temp_path
+
+      cmd.join(' ')
+    end
+  end
+end