asciidoc-pubkit 1.0.3 → 1.2.0

data/lib/asciidoc_pubkit/session.rb

@@ -51,6 +51,7 @@ module AsciidocPubkit
           'protected' => protected_content(document),
           'numeric_tokens' => numeric_tokens(document)
         }
+        manifest['outline_criteria'] = Writing.outline_criteria(settings.data['language']) if settings.data['scope'] == 'headings'
         write_json(File.join(staging, 'document.json'), document.to_h)
         write_json(File.join(staging, 'findings.json'), findings)
         manifest['artifacts'] = %w[document.json findings.json].to_h do |name|
@@ -157,14 +158,21 @@ module AsciidocPubkit
       @manifest.fetch('settings').fetch('language')
     end
 
-    def prompt(mode)
+    def prompt(mode, view: 'full')
+      raise Error, 'view must be full or outline.' unless %w[full outline].include?(view)
+      if view == 'outline' && @manifest.fetch('settings').fetch('scope', 'prose') != 'headings'
+        raise Error, 'Outline view requires a heading session.'
+      end
+      if view == 'outline' && !@manifest['outline_criteria'].is_a?(String)
+        raise Error, 'Outline view requires saved outline criteria. Create a new heading session without replacing the existing baseline.'
+      end
       raise Error, 'mode must be revise or diagnose.' unless %w[revise diagnose].include?(mode)
       stale = @manifest['sources'].select do |source|
         !File.file?(source['path']) || Digest::SHA256.file(source['path']).hexdigest != source['sha256']
       end
       raise Error, 'Sources have changed since scanning. Create a new scan before generating a prompt.' unless stale.empty?
       language = Language.validate!(@manifest.fetch('settings').fetch('language'), operation: 'review')
-      return heading_prompt(mode, language) if @manifest.fetch('settings').fetch('scope', 'prose') == 'headings'
+      return heading_prompt(mode, language, view: view) if @manifest.fetch('settings').fetch('scope', 'prose') == 'headings'
       list_scope = @manifest['settings']['scope'] == 'lists'
       criteria = @manifest.fetch('writing_criteria')
       instructions = <<~TEXT
@@ -332,7 +340,7 @@ module AsciidocPubkit
       end
     end
 
-    def heading_prompt(mode, language)
+    def heading_prompt(mode, language, view: 'full')
       text = <<~TEXT
         # Japanese heading review
 
@@ -399,6 +407,14 @@ module AsciidocPubkit
         ## Selected headings
 
       TEXT
+      if view == 'outline'
+        text.sub!('# Japanese heading review', '# Japanese outline review')
+        text.sub!(prompt_data(JSON.generate(@document.fetch('outline')), 'json'), outline_view_data)
+        text.sub!('## Outline (reference data)', outline_review_guidance + "\n## Outline (reference data)")
+      end
+      if (depth = @manifest['settings']['heading_depth'])
+        text.sub!('## Selected headings', "Selected heading depth: #{depth} (maximum Asciidoctor section level).\nDeeper titles are reference data only and remain protected.\n\n## Selected headings")
+      end
       grouped = @findings.group_by { |finding| finding['heading_id'] }
       @document.fetch('headings').each do |heading|
         text << "### Heading #{heading['id']}\n\n"
@@ -415,6 +431,28 @@ module AsciidocPubkit
       text
     end
 
+    def outline_review_guidance
+      @manifest.fetch('outline_criteria')
+    end
+
+    def outline_view_data
+      selected = @document.fetch('headings').to_h { |h| [h['index'], h] }
+      numbers = {}
+      siblings = Hash.new(0)
+      rows = @document.fetch('outline').map do |heading|
+        parent = heading['parent_index']
+        siblings[parent] += 1
+        number = (numbers[parent] || []) + [siblings[parent]]
+        numbers[heading['index']] = number
+        source = selected[heading['index']] || heading
+        location = source['file'] ? "#{source['file']}:#{source['line'] || '?'}" : 'source position unavailable'
+        status = selected.key?(heading['index']) ? 'editable' : 'reference-only'
+        "#{'  ' * (number.length - 1)}#{number.join('-')}. #{heading['text']} " \
+          "[#{status}; level #{heading['level']}; section_id #{heading['section_id']}; #{location}]"
+      end
+      prompt_data(rows.join("\n"), 'text')
+    end
+
     def review_process(unit, mode)
       <<~TEXT
         ## Review decisions and completion
@@ -423,10 +461,14 @@ module AsciidocPubkit
         Check mechanical preservation and baseline integrity with this session before editing and at completion. If a baseline or artifact integrity check fails, stop editing, preserve the evidence, and report the failure. Do not repair or overwrite snapshots, update their hashes, or replace the session to turn a failed check into a successful report; a fresh scan cannot prove preservation against the original baseline.
         Record each reviewed #{unit} ID and each candidate ID with revise, keep, or needs-evidence and a reason grounded in that passage. For keep, identify the concrete referent, operation, condition, necessary distinction, or established terminology that justifies retaining it. A shared generic reason does not establish individual review. Appending a source quotation to a stock reason is still insufficient.
         For each candidate decision, identify its concrete role or claim, the evidence and source location, the direct wording considered, and why that alternative is better or why the original wording is necessary. For needs-evidence, name the missing support instead of inventing a role or revision. A quotation supports evidence but does not substitute for that explanation. For role metaphors such as 入口, apply the shared criteria even when a nearby identifier makes the referent clear.
+        For broad or everyday wording, record a concrete alternative and a passage-specific comparison before choosing keep or revise. Apply the saved shared terminology criteria even when the original is understandable. A passage summary is not a wording comparison.
+        Reporting helpers may validate and count explicit assessments but must not manufacture keep decisions or inherit a paragraph summary as a candidate assessment. Missing or insufficient comparisons remain pending; they are not needs-evidence unless factual support is missing. Automatic decisions and zero pending counts cannot establish completion.
         Never infer revise or keep from whether the matched string survives, disappears, or changes. Do not bulk-assign keep to unchanged #{unit}s or remaining candidates. An unreviewed item stays pending; use needs-evidence only after review identifies missing evidence.
         Review #{unit}s without candidates against the shared criteria as well. For concerns outside the editable scope, report the location and a separate out-of-scope proposal; do not count protection as an editorial keep decision or edit protected content.
         #{mode == 'revise' ? 'Compare the original and edited passages, check both information loss and unsupported additions, and reconcile each recorded decision with the actual diff. After verification, individually inspect newly detected or remaining candidates; retain the original candidate IDs in the review record.' : 'Compare each proposed revision with the original passage for information loss and unsupported additions. A revise decision means a proposed revision, not an applied edit.'}
         Report mechanical preservation, candidate decisions, and #{unit}-level quality review separately. State selected and reviewed #{unit} counts, candidate decision counts, pending items, needs-evidence items, out-of-scope concerns, and evidence used. Recheck retained role metaphors by their actual roles and cite the individual decisions; listing remaining words is not enough. Out-of-scope concerns cover only evidence actually inspected; the supplied prose/body context omits lists and other excluded blocks, so do not claim those were reviewed. If any selected item or candidate remains pending, report the review as incomplete.
+        For an explicitly task-limited review (such as human-role terminology), state the objective and relevant entry IDs separately from the total scanned entries. Report task-specific decisions and full-quality review counts separately. Scanning the whole book or completing a terminology pass does not establish full editorial review; unrelated unreviewed entries and candidates remain pending, not automatic keep decisions. This reporting distinction does not change saved edit permissions or add a selection filter.
+        Check related tables, figures and alternative text when terminology changes affect them. Report updates outside this session's edit scope separately; this prompt does not authorize those edits. Preserve the original baseline and phase-end verification when separately authorized synchronization follows.
         Mechanical verification does not read or validate these decision records. Its passed result and candidate counts do not establish review completion or writing quality; meaning_verified remains false. Do not claim semantic correctness from those checks.
       TEXT
     end

data/lib/asciidoc_pubkit/settings.rb

@@ -23,7 +23,7 @@ module AsciidocPubkit
       reject_keys(config, ['review'], 'configuration')
       review = config.fetch('review', {})
       raise Error, 'review must be a mapping.' unless review.is_a?(Hash)
-      reject_keys(review, %w[language style glossary exclude allows attributes base_dir tokenizer mecab_command mecab_dictionary rules heading_rules], 'review')
+      reject_keys(review, %w[language style glossary exclude allows attributes base_dir tokenizer mecab_command mecab_dictionary rules heading_rules heading_depth], 'review')
       raise Error, 'attributes must be a mapping.' unless review.fetch('attributes', {}).is_a?(Hash)
       %w[base_dir glossary mecab_command mecab_dictionary rules heading_rules].each do |key|
         raise Error, "#{key} must be a nonempty path string." if review.key?(key) && (!review[key].is_a?(String) || review[key].empty?)
@@ -38,6 +38,16 @@ module AsciidocPubkit
       if scope != 'headings' && options[:heading_rules]
         raise Error, '--heading-rules requires --scope headings.'
       end
+      if options.key?(:depth) && scope != 'headings'
+        raise Error, '--depth requires --scope headings.'
+      end
+      if review.key?('heading_depth') && (!review['heading_depth'].is_a?(Integer) || review['heading_depth'] < 1)
+        raise Error, 'heading_depth must be a positive integer.'
+      end
+      depth = options.fetch(:depth, review['heading_depth']) if scope == 'headings'
+      if depth && (!depth.is_a?(Integer) || depth < 1)
+        raise Error, 'Depth must be a positive integer.'
+      end
       heading_rules_path = options[:heading_rules] ? File.expand_path(options[:heading_rules]) : (review['heading_rules'] ? File.expand_path(review['heading_rules'], base) : HeadingRuleSet.default_path(language))
       rules_path = options[:replacement] ? RuleSet.default_path(language) : options[:rules] ? File.expand_path(options[:rules]) : (review['rules'] ? File.expand_path(review['rules'], base) : RuleSet.default_path(language))
       @data = {
@@ -58,6 +68,7 @@ module AsciidocPubkit
         'base_dir' => File.expand_path(options[:base_dir] || review.fetch('base_dir', base), options[:base_dir] ? Dir.pwd : base),
         'glossary' => {}
       }
+      @data['heading_depth'] = depth if depth
       raise Error, 'tokenizer must be mecab or literal.' unless %w[mecab literal].include?(@data['tokenizer'])
       raise Error, 'style must be preserve, desu-masu, or dearu.' unless %w[preserve desu-masu dearu].include?(@data['style'])
       %w[exclude allows].each do |key|

data/lib/asciidoc_pubkit/skill_commands.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'find'
+require 'tmpdir'
+require 'rubygems/version'
+
+module AsciidocPubkit
+  # Manages bundled skills at an explicit path or agent-specific project path.
+  class SkillCommands
+    MANIFEST = '.asciidoc-pubkit-skill.json'
+    LOCK = '.asciidoc-pubkit-skills.lock'
+    AGENT_DIRECTORIES = { 'codex' => '.agents/skills', 'claude' => '.claude/skills' }.freeze
+
+    def self.bundled_root
+      File.expand_path('../../examples/skills', __dir__)
+    end
+
+    def self.run(command, args, out:, err:)
+      raise Error, 'Unknown skill command. Use skill --help.' unless %w[list install status upgrade].include?(command)
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: asciidoc-pubkit skill #{command}#{command == 'list' ? '' : ' NAME (--agent AGENT | --dir PATH)'} [options]"
+        unless command == 'list'
+          opts.on('--dir PATH', 'Explicit parent directory for installed skills') { |v| options[:dir] = v }
+          opts.on('--agent AGENT', AGENT_DIRECTORIES.keys, 'Project destination: codex or claude (does not invoke an agent)') { |v| options[:agent] = v }
+        end
+        opts.on('--json', 'Output structured skill information') { options[:json] = true } if %w[list status].include?(command)
+        opts.on('-h', '--help', 'Show command help') { options[:help] = true }
+      end
+      parser.parse!(args)
+      if options[:help]
+        out.puts parser
+        return 0
+      end
+      if command == 'list'
+        raise Error, 'skill list does not accept a name or destination.' unless args.empty?
+        skills = Dir.children(bundled_root).sort.select { |name| File.directory?(File.join(bundled_root, name)) }.map { |name| new(name).info }
+        out.puts(options[:json] ? JSON.pretty_generate({ 'tool_version' => VERSION, 'skills' => skills }) : skills.map { |s| "#{s['name']}: #{s['description']}" }.join("\n"))
+        return 0
+      end
+      if options[:dir] && options[:agent]
+        raise Error, 'Choose either --agent AGENT or --dir PATH, not both.'
+      end
+      directory = options[:dir] || AGENT_DIRECTORIES[options[:agent]]
+      unless args.length == 1 && directory && !directory.empty?
+        raise Error, 'Provide one bundled skill name and either --agent AGENT or --dir PATH.'
+      end
+      skill = new(args.first)
+      root = File.expand_path(directory)
+      check_path(root)
+      destination = File.join(root, skill.name)
+      if command == 'status'
+        report = skill.status(destination)
+        out.puts(options[:json] ? JSON.pretty_generate(report) : format_status(report))
+        return report['state'] == 'current' ? 0 : 1
+      end
+      if command == 'upgrade' && !%w[current update-available].include?(skill.status(destination)['state'])
+        raise Error, "Cannot upgrade this skill. Use skill status to inspect it; existing content was kept."
+      end
+      FileUtils.mkdir_p(root)
+      check_path(root)
+      lock = File.join(root, LOCK)
+      begin
+        Dir.mkdir(lock, 0o700)
+      rescue Errno::EEXIST
+        raise Error, "Skill destination is locked: #{lock}. Another install or upgrade may be running."
+      end
+      begin
+        result = skill.publish(destination, command)
+      ensure
+        Dir.rmdir(lock)
+      end
+      if result == :unchanged
+        out.puts "Already current: #{destination}"
+        return 0
+      end
+      out.puts "#{command == 'install' ? 'Installed' : 'Upgraded'} #{skill.name} from asciidoc-pubkit #{VERSION}: #{destination}"
+      0
+    rescue Error, OptionParser::ParseError, SystemCallError, JSON::ParserError, Psych::Exception, ArgumentError => e
+      err.puts "Error: #{e.message}"
+      2
+    end
+
+    def self.check_path(path)
+      Pathname.new(path).ascend do |part|
+        raise Error, "Symlink paths are not supported: #{part}" if File.symlink?(part)
+        raise Error, "Expected a directory: #{part}" if File.exist?(part) && !File.directory?(part)
+      end
+    end
+
+    def self.format_status(report)
+      lines = ["Skill: #{report['name']}", "Destination: #{report['destination']}", "State: #{report['state']}",
+               "Installed pubkit: #{report['installed_version'] || 'unknown'}", "Available pubkit: #{VERSION}"]
+      %w[modified missing extra updated].each do |kind|
+        report.fetch(kind, []).each { |file| lines << "#{kind.capitalize}: #{file}" }
+      end
+      lines.join("\n")
+    end
+
+    attr_reader :name
+
+    def initialize(name)
+      raise Error, 'Invalid skill name.' unless name.match?(/\A[a-z0-9]+(?:-[a-z0-9]+)*\z/) && name.length <= 64
+      @name = name
+      @source = File.join(self.class.bundled_root, name)
+      raise Error, "Unknown bundled skill: #{name}. Use skill list." unless File.directory?(@source)
+      self.class.check_path(@source)
+      @files = snapshot(@source)
+      raise Error, 'Bundled skill contains reserved registration metadata.' if @files.key?(MANIFEST)
+      text = AsciidocPubkit.read_text(File.join(@source, 'SKILL.md'))
+      frontmatter = text.match(/\A---\n(.*?)\n---(?:\n|\z)/m)
+      metadata = frontmatter && YAML.safe_load(frontmatter[1], permitted_classes: [], aliases: false)
+      unless metadata.is_a?(Hash) && metadata['name'] == name && metadata['description'].is_a?(String) && !metadata['description'].strip.empty?
+        raise Error, "Invalid bundled SKILL.md: #{name}"
+      end
+      @description = metadata['description']
+    end
+
+    def info
+      { 'name' => name, 'description' => @description, 'tool_version' => VERSION, 'files' => @files.keys.sort }
+    end
+
+    def snapshot(root)
+      files = {}
+      Find.find(root) do |path|
+        raise Error, "Symlink skill content is not supported: #{path}" if File.symlink?(path)
+        next if File.directory?(path)
+        raise Error, "Unsupported skill file: #{path}" unless File.file?(path)
+        relative = Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
+        files[relative] = Digest::SHA256.file(path).hexdigest
+      end
+      files
+    end
+
+    def registration(destination)
+      path = File.join(destination, MANIFEST)
+      raise Error, "Symlink registration is not supported: #{path}" if File.symlink?(path)
+      return nil unless File.exist?(path)
+      raise Error, "Expected a registration file: #{path}" unless File.file?(path)
+      data = JSON.parse(AsciidocPubkit.read_text(path))
+      valid = data.is_a?(Hash) && data.keys.sort == %w[files name schema_version tool tool_version] &&
+              data['schema_version'] == 1 && data['tool'] == 'asciidoc-pubkit' && data['name'] == name &&
+              data['tool_version'].is_a?(String) && !data['tool_version'].empty? && Gem::Version.correct?(data['tool_version']) &&
+              data['files'].is_a?(Hash) && data['files'].key?('SKILL.md') && !data['files'].key?(MANIFEST)
+      valid &&= data['files'].all? do |file, sha|
+        file.is_a?(String) && !file.empty? && !file.start_with?('/') && !file.include?('\\') &&
+          file.split('/', -1).none? { |part| ['', '.', '..'].include?(part) || part.include?("\0") } &&
+          sha.is_a?(String) && sha.match?(/\A[0-9a-f]{64}\z/)
+      end
+      raise Error, "Invalid skill registration: #{path}" unless valid
+      data
+    end
+
+    def status(destination)
+      self.class.check_path(destination)
+      report = { 'name' => name, 'destination' => destination, 'available_version' => VERSION,
+                 'installed_version' => nil, 'state' => 'not-installed', 'modified' => [], 'missing' => [], 'extra' => [], 'updated' => [] }
+      return report unless File.directory?(destination)
+      data = registration(destination)
+      return report.merge('state' => 'unmanaged') unless data
+      actual = snapshot(destination).reject { |file, _| file == MANIFEST }
+      expected = data['files']
+      report['installed_version'] = data['tool_version']
+      report['modified'] = (expected.keys & actual.keys).select { |file| expected[file] != actual[file] }.sort
+      report['missing'] = (expected.keys - actual.keys).sort
+      report['extra'] = (actual.keys - expected.keys).sort
+      # Even empty additional directories are user-owned content.
+      permitted_dirs = expected.keys.flat_map do |file|
+        parts = file.split('/')[0...-1]
+        (1..parts.length).map { |length| parts.first(length).join('/') }
+      end
+      Find.find(destination) do |path|
+        next unless File.directory?(path) && path != destination
+        relative = Pathname.new(path).relative_path_from(Pathname.new(destination)).to_s
+        report['extra'] << relative + '/' unless permitted_dirs.include?(relative)
+      end
+      report['extra'].sort!
+      report['updated'] = (expected.keys | @files.keys).select { |file| expected[file] != @files[file] }.sort
+      report['state'] = if %w[modified missing extra].any? { |kind| !report[kind].empty? }
+                          'modified'
+                        elsif Gem::Version.new(data['tool_version']) > Gem::Version.new(VERSION)
+                          'newer-installed'
+                        elsif data['tool_version'] != VERSION || !report['updated'].empty?
+                          'update-available'
+                        else
+                          'current'
+                        end
+      report
+    end
+
+    def publish(destination, command)
+      self.class.check_path(destination)
+      if command == 'install'
+        raise Error, "Skill destination already exists: #{destination}. Use skill status or choose a different directory." if File.exist?(destination)
+      else
+        report = status(destination)
+        unless %w[current update-available].include?(report['state'])
+          raise Error, "Cannot upgrade #{report['state']} skill: #{destination}. Use skill status to inspect it; existing content was kept."
+        end
+        return :unchanged if report['state'] == 'current'
+      end
+      workspace = Dir.mktmpdir('.asciidoc-pubkit-skill-', File.dirname(destination))
+      staged = File.join(workspace, 'new')
+      backup = File.join(workspace, 'old')
+      preserve_backup = false
+      begin
+        Dir.mkdir(staged)
+        @files.each do |file, sha|
+          source = File.join(@source, file)
+          raise Error, 'Bundled skill changed while staging.' unless Digest::SHA256.file(source).hexdigest == sha
+          target = File.join(staged, file)
+          FileUtils.mkdir_p(File.dirname(target))
+          FileUtils.copy_file(source, target)
+          File.chmod(File.stat(source).mode & 0o777, target)
+          raise Error, 'Bundled skill changed while copying.' unless Digest::SHA256.file(target).hexdigest == sha
+        end
+        File.write(File.join(staged, MANIFEST), JSON.pretty_generate({ 'schema_version' => 1, 'tool' => 'asciidoc-pubkit',
+                                                                    'name' => name, 'tool_version' => VERSION, 'files' => @files }) + "\n")
+        self.class.check_path(destination)
+        if command == 'upgrade'
+          raise Error, 'Installed skill changed while staging.' unless status(destination) == report
+          File.rename(destination, backup)
+        elsif File.exist?(destination)
+          raise Error, "Skill destination already exists: #{destination}"
+        end
+        begin
+          File.rename(staged, destination)
+        rescue SystemCallError
+          if File.directory?(backup)
+            preserve_backup = true
+            begin
+              File.rename(backup, destination)
+              preserve_backup = false
+            rescue SystemCallError => restore_error
+              raise Error, "Could not restore the skill. Original content is preserved at #{backup}: #{restore_error.message}"
+            end
+          end
+          raise
+        end
+      ensure
+        FileUtils.remove_entry_secure(workspace) unless preserve_backup
+      end
+      :updated
+    end
+  end
+end

data/lib/asciidoc_pubkit/writing.rb

@@ -18,6 +18,11 @@ module AsciidocPubkit
       AsciidocPubkit.read_text(File.join(DATA_ROOT, language, 'headings.md'))
     end
 
+    def self.outline_criteria(language = Language::DEFAULT)
+      Language.validate!(language, operation: 'review')
+      AsciidocPubkit.read_text(File.join(DATA_ROOT, language, 'outline.md'))
+    end
+
     def self.prompt(language = Language::DEFAULT)
       guide = prompt_criteria(language)
       <<~TEXT

data/lib/asciidoc_pubkit.rb

@@ -9,7 +9,7 @@ require 'pathname'
 require 'optparse'
 
 module AsciidocPubkit
-  VERSION = '1.0.3'
+  VERSION = '1.2.0'
   class Error < StandardError; end
 
   def self.hash_text(text)
@@ -36,4 +36,5 @@ require_relative 'asciidoc_pubkit/local_evaluator'
 require_relative 'asciidoc_pubkit/score'
 require_relative 'asciidoc_pubkit/replacement'
 require_relative 'asciidoc_pubkit/document_commands'
+require_relative 'asciidoc_pubkit/skill_commands'
 require_relative 'asciidoc_pubkit/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciidoc-pubkit
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.2.0
 platform: ruby
 authors:
 - CyberGarage
@@ -53,6 +53,8 @@ files:
 - data/review-rules.ja.yml
 - data/writing/ja/criteria.md
 - data/writing/ja/headings.md
+- data/writing/ja/outline.md
+- docs/agent-review-tutorial.md
 - docs/architecture.md
 - docs/configuration.md
 - docs/custom-rules.md
@@ -61,15 +63,19 @@ files:
 - docs/english-review-research.md
 - docs/installation.md
 - docs/list-review.md
+- docs/outline-review.md
 - docs/prose-evaluation.md
 - docs/references.md
 - docs/replacements.md
 - docs/review-workflow.md
 - docs/rules-and-coverage.md
 - docs/scoring.md
+- docs/skill-commands.md
+- docs/skill-integration.md
 - docs/writing.md
 - examples/book.adoc
 - examples/replacements.yml
+- examples/skills/review-asciidoc-manuscript/SKILL.md
 - exe/asciidoc-pubkit
 - lib/asciidoc_pubkit.rb
 - lib/asciidoc_pubkit/cli.rb
@@ -85,6 +91,7 @@ files:
 - lib/asciidoc_pubkit/score.rb
 - lib/asciidoc_pubkit/session.rb
 - lib/asciidoc_pubkit/settings.rb
+- lib/asciidoc_pubkit/skill_commands.rb
 - lib/asciidoc_pubkit/writing.rb
 homepage: https://github.com/cybergarage/asciidoc-pubkit
 licenses: