wiki_promoter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 49ad9cfb63d2cfd271010eca6a921eec3e92e093cd8de1c261b2c7a708ca3216
+  data.tar.gz: c19692e580ab14ac6f1f7d8da21dae691dbafd133a801c2153f7592c306f3935
+SHA512:
+  metadata.gz: 1b1389319179165e05c710354f22ed36ba3ed16232958e9fc24fafac8e39fcad7028a7125ab67498ab6c2e55269b3f913ca50866d645441d7516155d84a7265e
+  data.tar.gz: f26d49102ad80218c57527bceb9345a31b5a26ae57404ac75bccbb5736a32d526ac73a7e7657bf13439c36643171494ad4754e41d8b65fc5c023e8607019af42

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-07-05
+
+### Added
+
+- Initial release of `wiki_promoter` gem
+- Core `Migrator` class for flattening and relinking markdown research trees
+- Hierarchical page naming with alphabetic, roman, and numeric numbering
+- Link rewriting to reference new wiki page names
+- Collision detection for duplicate page names
+- `repoint_references` method for updating roadmap references
+- CLI executable: `wiki-promoter migrate`
+- Rake tasks: `wiki:migrate` and `wiki:publish`
+- Portable publisher implementation for wiki sync, Home index updates, roadmap repointing, and source cleanup
+- Composite action wired through the shared CLI publish workflow
+- Comprehensive unit and edge-case tests
+- Composite GitHub Action wrapper in `action/action.yml`

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GitHub Copilot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,176 @@
+# GitHub Wiki Research PR
+
+A pure-Ruby gem for mechanized promotion of markdown research/planning documents from a `docs/` hierarchy into a GitHub Wiki. Includes a CLI tool and composite GitHub Action.
+
+## Features
+
+- **Hierarchical page naming**: Automatically generates numbered, cased wiki page titles from directory structure
+- **Link rewriting**: Rewrites relative links to reference new wiki page names
+- **Collision detection**: Detects and reports when multiple source files would flatten to the same wiki page
+- **Roadmap reference repointing**: Targeted literal replacement for updating roadmap doc references after source deletion
+- **Pure Ruby**: No native extensions, no external dependencies
+- **CLI & Rake tasks**: Exposes both a command-line tool and reusable Rake tasks
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "wiki_promoter"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### CLI
+
+```bash
+wiki-promoter migrate --output-dir /tmp/wiki docs/77-your-research-tree
+```
+
+This flattens and relinks the docs tree into GitHub Wiki format, outputting to the specified directory.
+
+### Rake Tasks
+
+Add to your `Rakefile`:
+
+```ruby
+require "wiki_promoter/tasks"
+```
+
+Then use:
+
+```bash
+bundle exec rake wiki:migrate[docs/77-your-tree]
+bundle exec rake wiki:publish[docs/77-your-tree]
+```
+
+`wiki:publish` expects `WIKI_DEPLOY_TOKEN` and `WIKI_REPOSITORY` (for example,
+`your-org/your-repo.wiki`). Optional environment variables include
+`ROADMAP_PATH`, `UPDATE_HOME_PAGE`, `SOURCE_REPOSITORY`, `WIKI_FORCE`,
+`WIKI_BRANCH`, `WIKI_OUTPUT_DIR`, and `WIKI_CHECKOUT_DIR`.
+
+`WIKI_DEPLOY_TOKEN` must be a classic GitHub PAT with `repo` scope — the
+default `GITHUB_TOKEN` cannot push to a repository's wiki. See
+[Local secrets](#local-secrets) for running this locally via `.env.local`.
+
+### Ruby API
+
+```ruby
+require "wiki_promoter"
+
+migrator = WikiPromoter::Migrator.new("docs/77-your-tree")
+pages = migrator.pages  # => {"77. Title.md" => "content", ...}
+```
+
+## Development
+
+### Setup
+
+```bash
+bin/setup
+```
+
+### Local secrets
+
+Copy `.env.sample` to `.env.local` (gitignored) and fill in real values:
+
+```bash
+cp .env.sample .env.local
+```
+
+`bundle exec rake` loads `.env.local` automatically via `dotenv`, so tasks
+like `wiki:publish` can pick up `WIKI_DEPLOY_TOKEN` without exporting it by
+hand. See `.env.sample` for what each variable is for.
+
+### Running Tests
+
+```bash
+bundle exec rake test
+```
+
+### Running Linter
+
+```bash
+bundle exec standardrb
+```
+
+### Fixing Linter Issues
+
+```bash
+bundle exec standardrb --fix
+```
+
+### Releasing
+
+Releases publish to [rubygems.org](https://rubygems.org) via
+`.github/workflows/release.yml`, which runs on any pushed `v*` tag.
+
+**One-time setup:**
+
+1. Create (or use an existing) [rubygems.org](https://rubygems.org) account.
+2. Under [Profile → API Keys](https://rubygems.org/profile/edit), create a key
+   scoped to "Push rubygem" (optionally restricted to the `wiki_promoter`
+   gem).
+3. Add it as a GitHub Actions repo secret named `RUBYGEMS_API_KEY`:
+   `gh secret set RUBYGEMS_API_KEY --repo cpb/wiki_promoter`, or via
+   **Settings → Secrets and variables → Actions**.
+
+**Cutting a release:**
+
+1. Bump the version in `lib/wiki_promoter/version.rb`.
+2. Update `CHANGELOG.md`.
+3. Commit, then tag and push: `git tag vX.Y.Z && git push origin vX.Y.Z`.
+4. The `release` workflow builds the gem and runs `gem push` using the
+   `RUBYGEMS_API_KEY` secret — no manual `gem push` needed.
+
+## Docs Structure Conventions
+
+The gem expects `docs/` trees to follow this naming pattern:
+
+```
+docs/
+├── 77-issue-slug/           # Issue number required, slug auto-becomes entry page name
+│   ├── README.md            # Becomes "77. ..."
+│   ├── research/
+│   │   ├── README.md        # Becomes "77.a. ..."
+│   │   ├── data.md          # Becomes "77.a.i. ..."
+│   │   └── ...
+│   ├── analysis/
+│   │   ├── README.md        # Becomes "77.b. ..."
+│   │   └── ...
+│   └── ...
+```
+
+**Numbering rules:**
+- Root level: Issue number (e.g., `77`)
+- Subdirectories: Alphabetic (`a`, `b`, `c`, ...)
+- Files in each dir: Numeric (`1`, `2`, `3`, ...) or Roman (`i`, `ii`, `iii`, ...) depending on depth
+
+**Page titles:**
+- Extracted from H1 markdown headings (`# Title`)
+- Unsafe characters (`*`, `:`, `?`, etc.) stripped
+- Consecutive spaces collapsed
+- Long titles truncated to 120 characters with `…`
+
+## GitHub Action
+
+The `action/` directory defines a composite GitHub Action that runs the migration workflow end-to-end: flatten pages, sync the wiki, optionally update `Home.md`, repoint roadmap references, remove the source docs tree, and push the cleanup commit back to the branch.
+
+```yaml
+- uses: your-org/wiki_promoter/action@v1
+  with:
+    docs_path: docs/77-spike-slug
+    wiki_deploy_token: ${{ secrets.WIKI_DEPLOY_TOKEN }}
+    wiki_repository: your-org/your-repo.wiki
+    roadmap_path: docs/2026-07-01-roadmap.md
+```
+
+## License
+
+MIT

data/action/action.yml

@@ -0,0 +1,100 @@
+# Composite action that flattens a docs/<issue>-slug research tree, pushes it
+# to the repository's wiki, updates Home.md, repoints the roadmap, and removes
+# the source tree from the PR branch.
+#
+# NOTE: this action performs its OWN checkout of the calling repository into
+# ${{ github.workspace }} (it needs the docs tree and push access to the PR
+# branch). Do not rely on a checkout your workflow ran earlier — this step
+# will reset the workspace to github.ref.
+name: "Migrate Docs to Wiki"
+description: "Flatten, migrate, and sync GitHub Markdown research trees to GitHub Wiki"
+
+inputs:
+  docs_path:
+    description: "Path to the docs/<issue>-<slug> research tree to migrate (required)"
+    required: true
+  wiki_deploy_token:
+    description: "Classic PAT with 'repo' scope for wiki read/write access (required)"
+    required: true
+  wiki_repository:
+    description: "Target wiki repository, e.g. org/repo.wiki. Defaults to the current repository's wiki."
+    required: false
+  roadmap_path:
+    description: "Path to roadmap markdown file for reference repointing (defaults to docs/2026-07-01-roadmap.md)"
+    required: false
+    default: "docs/2026-07-01-roadmap.md"
+  update_home_page:
+    description: "Whether to auto-index the entry page on Home.md (defaults to 'true')"
+    required: false
+    default: "true"
+  entry_page_name:
+    description: "Override for the auto-derived wiki entry page name (optional)"
+    required: false
+  force:
+    description: "Whether to force publishing despite unsupported file types or overwriting different wiki pages (defaults to 'false')"
+    required: false
+    default: "false"
+  pr_number:
+    description: "PR number this branch belongs to; when set, posts a summary comment linking the migrated wiki page (optional)"
+    required: false
+  ref:
+    description: "Branch name to check out and push the cleanup commit to (defaults to the workflow's ref)"
+    required: false
+
+runs:
+  using: "composite"
+  steps:
+    - name: "Check out repository"
+      uses: "actions/checkout@v4"
+      with:
+        token: ${{ github.token }}
+        ref: ${{ inputs.ref || github.ref }}
+
+    - name: "Set up Ruby"
+      uses: "ruby/setup-ruby@v1"
+      with:
+        ruby-version: "3.3"
+
+    - name: "Publish docs tree"
+      id: "publish"
+      shell: "bash"
+      env:
+        DOCS_PATH: "${{ inputs.docs_path }}"
+        WIKI_DEPLOY_TOKEN: "${{ inputs.wiki_deploy_token }}"
+        WIKI_REPOSITORY: "${{ inputs.wiki_repository || format('{0}.wiki', github.repository) }}"
+        ROADMAP_PATH: "${{ inputs.roadmap_path }}"
+        UPDATE_HOME_PAGE: "${{ inputs.update_home_page }}"
+        ENTRY_PAGE_NAME: "${{ inputs.entry_page_name }}"
+        WIKI_FORCE: "${{ inputs.force }}"
+        SOURCE_REPOSITORY: "${{ github.repository }}"
+        GITHUB_SERVER_URL: "${{ github.server_url }}"
+        GITHUB_REF_NAME: "${{ inputs.ref || github.ref_name }}"
+        WIKI_OUTPUT_DIR: "${{ runner.temp }}/wiki-migration"
+        WIKI_CHECKOUT_DIR: "${{ runner.temp }}/wiki"
+        GIT_USER_NAME: "github-actions[bot]"
+        GIT_USER_EMAIL: "github-actions[bot]@users.noreply.github.com"
+      # action.yml lives in action/, so the gem's lib/ and exe/ are one level
+      # up from github.action_path.
+      run: |
+        cd "${{ github.workspace }}"
+        gem_root="${{ github.action_path }}/.."
+        url="$(ruby -I"${gem_root}/lib" -e 'require "wiki_promoter"; name = ENV["ENTRY_PAGE_NAME"].to_s.empty? ? nil : ENV["ENTRY_PAGE_NAME"]; migrator = WikiPromoter::Migrator.new(ENV.fetch("DOCS_PATH"), entry_page_name: name); entry = migrator.entry_wiki_name.tr(" ", "-"); puts "#{ENV.fetch("GITHUB_SERVER_URL")}/#{ENV.fetch("SOURCE_REPOSITORY")}/wiki/#{entry}"')"
+        ruby -I"${gem_root}/lib" "${gem_root}/exe/wiki-promoter" publish "${DOCS_PATH}"
+        echo "url=${url}" >> "${GITHUB_OUTPUT}"
+
+    - name: "Comment on the PR"
+      if: inputs.pr_number != ''
+      shell: "bash"
+      env:
+        GH_TOKEN: "${{ github.token }}"
+        PR_NUMBER: "${{ inputs.pr_number }}"
+        DOCS_PATH: "${{ inputs.docs_path }}"
+        WIKI_URL: "${{ steps.publish.outputs.url }}"
+      run: |
+        cd "${{ github.workspace }}"
+        gh pr comment "${PR_NUMBER}" --body "Migrated \`${DOCS_PATH}\` to the wiki: ${WIKI_URL}"
+
+outputs:
+  wiki_url:
+    description: "URL to the wiki entry page"
+    value: ${{ steps.publish.outputs.url }}

data/exe/wiki-promoter

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/wiki_promoter"
+
+def print_usage
+  puts "Usage:"
+  puts "  wiki-promoter migrate [--output-dir DIR] [--force] DOCS_PATH"
+  puts "  wiki-promoter publish [--force] DOCS_PATH"
+  puts ""
+  puts "Flattens and relinks a docs/ research tree into GitHub Wiki format."
+  puts "The publish command also syncs the wiki, updates Home.md, repoints roadmap references, and removes the source tree."
+  puts ""
+  puts "Arguments:"
+  puts "  DOCS_PATH          Path to docs/<issue>-<slug> tree to migrate"
+  puts ""
+  puts "Options:"
+  puts "  --output-dir DIR   Output directory (default: tmp/wiki-migration)"
+  puts "  --force, -f        Force publication / migration bypassing validation"
+  puts "  --help             Show this help message"
+end
+
+def main
+  if ARGV.empty? || ARGV.include?("--help")
+    print_usage
+    exit(ARGV.empty? ? 1 : 0)
+  end
+
+  command = ARGV.shift
+  unless %w[migrate publish].include?(command)
+    puts "Unknown command: #{command}"
+    print_usage
+    exit 1
+  end
+
+  output_dir = "tmp/wiki-migration"
+  docs_path = nil
+  force = false
+
+  while ARGV.any?
+    arg = ARGV.shift
+    case arg
+    when "--output-dir"
+      output_dir = ARGV.shift
+      raise ArgumentError, "--output-dir requires a value" unless output_dir
+    when "--force", "-f"
+      force = true
+    when "--help"
+      print_usage
+      exit 0
+    else
+      docs_path = arg
+    end
+  end
+
+  raise ArgumentError, "DOCS_PATH is required" unless docs_path
+
+  begin
+    ENV["WIKI_OUTPUT_DIR"] = output_dir
+    ENV["WIKI_FORCE"] = "true" if force
+
+    if command == "migrate"
+      publisher = WikiPromoter::Publisher.from_env(docs_path)
+      publisher.migrate
+      puts "Migration complete: #{publisher.migrator.pages.size} files written to #{output_dir}/"
+    else
+      result = WikiPromoter::Publisher.from_env(docs_path).publish
+      puts "Publishing complete: #{result.wiki_url}"
+    end
+  rescue ArgumentError => e
+    puts "Error: #{e.message}"
+    print_usage
+    exit 1
+  rescue WikiPromoter::Migrator::CollisionError => e
+    puts "Collision Error: #{e.message}"
+    exit 1
+  rescue => e
+    puts "Error: #{e.message}"
+    puts e.backtrace
+    exit 1
+  end
+end
+
+main if __FILE__ == $0

data/lib/wiki_promoter/migrator.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module WikiPromoter
+  class TreeNode
+    attr_reader :name, :parent, :subdirs, :files
+    attr_accessor :prefix
+
+    def initialize(name, parent = nil)
+      @name = name
+      @parent = parent
+      @subdirs = {}
+      @files = []
+    end
+
+    def add_file(path_parts, full_path)
+      if path_parts.empty?
+        raise "Empty path parts"
+      elsif path_parts.size == 1
+        @files << full_path
+      else
+        subdir_name = path_parts.first
+        @subdirs[subdir_name] ||= TreeNode.new(subdir_name, self)
+        @subdirs[subdir_name].add_file(path_parts[1..], full_path)
+      end
+    end
+  end
+
+  # Mechanizes the flatten + relink transform for converting hierarchical markdown
+  # research/planning trees into GitHub Wiki format. GitHub wikis route pages by
+  # basename only (ignoring directory structure), so every file gets a directory-prefixed,
+  # cased, and numbered page title (e.g. "77.a.i. Raw Experiment Data"). This groups
+  # and orders them logically in the sidebar. Internal relative links are rewritten
+  # to reference the new cased, numbered page titles.
+  class Migrator
+    ENTRY_SLUG_RE = %r{\A(?:.*/)?(\d+)-(.+)\z}
+    MD_LINK_RE = /\[([^\]]*)\]\(([^)\s]+)\)/
+    MAX_TITLE_LENGTH = 120
+
+    SUBDIR_STYLES = [:alpha, :roman, :numeric]
+    FILE_STYLES = [:numeric, :roman, :numeric]
+
+    CollisionError = Class.new(StandardError)
+
+    attr_reader :docs_path, :entry_page_name, :issue_number
+
+    def initialize(docs_path, entry_page_name: nil)
+      @docs_path = docs_path.chomp("/")
+      match = ENTRY_SLUG_RE.match(File.basename(@docs_path))
+      raise ArgumentError, "#{docs_path} doesn't look like a docs/<issue>-<slug> tree" unless match
+
+      @issue_number = match[1]
+      @entry_page_name = entry_page_name || ENV["ENTRY_PAGE_NAME"] || match[2]
+      @metadata = nil
+    end
+
+    def source_files
+      @source_files ||= Dir.glob(File.join(docs_path, "**", "*.md")).sort
+    end
+
+    # {relative_path_within_tree => flattened_wiki_filename_without_extension}
+    def wiki_names
+      build_metadata! unless @metadata
+      @wiki_names ||= source_files.each_with_object({}) do |path, memo|
+        rel = relative_path(path)
+        memo[rel] = @metadata.fetch(rel).fetch(:wiki_name)
+      end
+    end
+
+    def h1(content)
+      content[/^#\s+(.+)$/, 1]&.strip
+    end
+
+    # The flattened wiki page name for the tree's root entry document. GitHub
+    # wikis derive the entry page from the root README.md; a tree without one
+    # has no entry page, so fail loudly rather than with a bare KeyError.
+    def entry_wiki_name
+      wiki_names.fetch("README.md") do
+        raise ArgumentError, "#{docs_path} has no root README.md to serve as the wiki entry page"
+      end
+    end
+
+    def clean_title(h1_title)
+      return nil if h1_title.nil?
+      title = h1_title
+        .gsub(/[`"'\/\\:*?<>|]/, "")
+        .gsub(/\s+/, " ")
+        .strip
+
+      if title.length > MAX_TITLE_LENGTH
+        truncated = title[0, MAX_TITLE_LENGTH - 1].rstrip
+        return "#{truncated}…"
+      end
+
+      title
+    end
+
+    # {wiki_filename_with_extension => rewritten_markdown_content}
+    def pages
+      check_collisions!
+
+      titles = source_files.each_with_object({}) do |path, memo|
+        rel = relative_path(path)
+        build_metadata! unless @metadata
+        memo[rel] = @metadata.fetch(rel).fetch(:raw_h1) || @metadata.fetch(rel).fetch(:title)
+      end
+
+      source_files.each_with_object({}) do |path, memo|
+        rel = relative_path(path)
+        content = rewrite_links(File.read(path), rel, titles)
+        memo["#{wiki_names.fetch(rel)}.md"] = content
+      end
+    end
+
+    private
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(Pathname.new(docs_path)).to_s
+    end
+
+    def to_alpha(index)
+      result = ""
+      while index >= 0
+        result = ((index % 26) + 97).chr + result
+        index = (index / 26) - 1
+      end
+      result
+    end
+
+    def to_roman(index)
+      roman_mapping = {
+        10 => "x", 9 => "ix", 5 => "v", 4 => "iv", 1 => "i"
+      }
+      result = ""
+      n = index
+      roman_mapping.each do |value, letters|
+        while n >= value
+          result += letters
+          n -= value
+        end
+      end
+      result
+    end
+
+    def format_index(val, style)
+      case style
+      when :alpha
+        to_alpha(val)
+      when :roman
+        to_roman(val + 1)
+      else
+        (val + 1).to_s
+      end
+    end
+
+    def build_metadata!
+      @metadata = {}
+      root_node = TreeNode.new(docs_path)
+      source_files.each do |path|
+        rel = relative_path(path)
+        root_node.add_file(rel.split("/"), path)
+      end
+      assign_metadata(root_node, 0, nil)
+    end
+
+    def assign_metadata(node, depth, parent_prefix)
+      if depth == 0
+        node.prefix = @issue_number.to_s
+      end
+
+      # 1. Assign README.md
+      readme = node.files.find { |f| File.basename(f) == "README.md" }
+      if readme
+        file_prefix = node.prefix
+        raw_h1 = h1(File.read(readme))
+        cleaned_title = clean_title(raw_h1) || clean_title(File.basename(readme, ".md").tr("-_", " "))
+        if depth == 0
+          cleaned_title = cleaned_title.sub(/\AIssue\s+#?\d+\s*[\u2014:-]\s*/i, "")
+        end
+
+        rel_path = relative_path(readme)
+        @metadata[rel_path] = {
+          prefix: file_prefix,
+          raw_h1: raw_h1,
+          title: cleaned_title,
+          wiki_name: "#{file_prefix}. #{cleaned_title}"
+        }
+      end
+
+      # 2. Assign other files in this directory (sorted alphabetically, case-insensitive)
+      other_files = node.files.reject { |f| File.basename(f) == "README.md" }.sort_by { |f| File.basename(f).downcase }
+      file_style = FILE_STYLES[depth % FILE_STYLES.size]
+      other_files.each_with_index do |file_path, idx|
+        file_prefix = "#{node.prefix}.#{format_index(idx, file_style)}"
+        raw_h1 = h1(File.read(file_path))
+        cleaned_title = clean_title(raw_h1) || clean_title(File.basename(file_path, ".md").tr("-_", " "))
+
+        rel_path = relative_path(file_path)
+        @metadata[rel_path] = {
+          prefix: file_prefix,
+          raw_h1: raw_h1,
+          title: cleaned_title,
+          wiki_name: "#{file_prefix}. #{cleaned_title}"
+        }
+      end
+
+      # 3. Assign subdirectories and recurse
+      subdirs = node.subdirs.sort_by { |name, _| name.downcase }
+      subdir_style = SUBDIR_STYLES[depth % SUBDIR_STYLES.size]
+      subdirs.each_with_index do |(name, subdir_node), idx|
+        subdir_node.prefix = "#{node.prefix}.#{format_index(idx, subdir_style)}"
+        assign_metadata(subdir_node, depth + 1, node.prefix)
+      end
+    end
+
+    # Compare case-insensitively: GitHub wiki checkouts (and macOS/Windows
+    # working copies) are case-insensitive, so "77.a. Appendix" and
+    # "77.a. appendix" would clobber each other even though they are distinct
+    # strings.
+    def check_collisions!
+      dupes = wiki_names.values.group_by(&:downcase).select { |_, names| names.size > 1 }.keys
+      return if dupes.empty?
+
+      offenders = wiki_names.select { |_, name| dupes.include?(name.downcase) }
+      raise CollisionError, "Multiple source files would flatten to the same wiki page (case-insensitive): #{offenders}"
+    end
+
+    def rewrite_links(content, source_relative_path, titles)
+      source_dir = File.dirname(source_relative_path)
+      in_fence = false
+
+      content.each_line.map do |line|
+        if line.start_with?("```")
+          in_fence = !in_fence
+          next line
+        end
+        next line if in_fence
+
+        line.gsub(MD_LINK_RE) do |match|
+          text = $1
+          target = $2
+          resolved = resolve_internal_target(source_dir, target)
+          next match unless resolved
+
+          rel_target, anchor = resolved
+          wiki_name = wiki_names[rel_target]
+          next match unless wiki_name
+
+          "[#{titles[rel_target] || text}](#{WikiPromoter.encode_wiki_link_target(wiki_name)}#{anchor})"
+        end
+      end.join
+    end
+
+    # Returns [relative_path_within_tree, "#anchor-or-empty"] if `target` is a
+    # relative link to another .md file inside this tree, else nil (external
+    # URL, anchor-only link, non-.md target, or a path that escapes the tree).
+    def resolve_internal_target(source_dir, target)
+      return nil if target.start_with?("#") || target =~ %r{\A[a-z][a-z0-9+.-]*://}i
+
+      path, anchor = target.split("#", 2)
+      return nil unless path&.end_with?(".md")
+
+      base = (source_dir == ".") ? Pathname.new(docs_path) : Pathname.new(File.join(docs_path, source_dir))
+      absolute = (base + path).cleanpath
+      root = Pathname.new(docs_path).cleanpath
+      return nil unless absolute.to_s.start_with?("#{root}/")
+
+      rel = absolute.relative_path_from(root).to_s
+      return nil unless wiki_names.key?(rel)
+
+      [rel, anchor ? "##{slugify_anchor(anchor)}" : ""]
+    end
+
+    # Normalize a link's #fragment to GitHub's heading-anchor slug rules
+    # (downcase, drop punctuation, spaces -> hyphens) so it still resolves after
+    # flattening even when the author wrote it loosely (e.g. "#Two Track
+    # Methodology"). Idempotent on already-correct slugs, so links that already
+    # use GitHub slugs are unchanged.
+    def slugify_anchor(anchor)
+      anchor.downcase.gsub(/[^\p{Word}\s-]/u, "").gsub(/\s/, "-")
+    end
+  end
+
+  # Targeted literal find-and-replace for repointing references to a just-removed
+  # docs tree (bare relative path or a full GitHub blob permalink into it) at
+  # the new wiki pages. String substitution only, not free-form prose
+  # rewriting -- keeps this operation's side effects predictable.
+  #
+  # `page_urls` maps a specific source file path (e.g.
+  # "docs/77-slug/research/results.md") to its own flattened wiki URL. Those
+  # deep links are repointed at their specific sub-page (longest path first, so
+  # a nested file wins over its parent directory) before the whole `docs_path`
+  # tree falls back to `entry_url`. When `page_urls` is empty the behavior is
+  # identical to a single `docs_path` -> `entry_url` substitution.
+  def self.repoint_references(content, docs_path:, entry_url:, repository: nil, page_urls: {}, github_host: "https://github.com")
+    substitutions = page_urls
+      .sort_by { |path, _| -path.length }
+      .push([docs_path, entry_url])
+
+    substitutions.reduce(content) do |text, (path, url)|
+      pattern = if repository
+        %r{
+          (?:#{Regexp.escape(github_host)}/#{Regexp.escape(repository)}/blob/[^)\s"'\]]+/)?
+          #{Regexp.escape(path)}
+          [^)\s"'\]]*
+        }x
+      else
+        # If no repository specified, only match bare relative paths
+        %r{#{Regexp.escape(path)}[^)\s"'\]]*}
+      end
+      text.gsub(pattern, url)
+    end
+  end
+end

data/lib/wiki_promoter/publisher.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+
+module WikiPromoter
+  class Publisher
+    SUPPORTED_EXTENSIONS = %w[.png .jpg .jpeg .gif .svg .webp .ico .pdf .txt .csv .tsv .json .jsonld .xml .yml .yaml].freeze
+
+    PublishResult = Struct.new(:wiki_url, :pages) do
+      def initialize(wiki_url:, pages:)
+        super(wiki_url, pages)
+      end
+    end
+
+    attr_reader :docs_path, :entry_url, :migrator, :output_dir, :wiki_checkout
+
+    def initialize(
+      docs_path:,
+      wiki_repository: nil,
+      wiki_deploy_token: nil,
+      output_dir: File.join("tmp", "wiki-migration"),
+      wiki_checkout: File.join("tmp", "wiki-checkout"),
+      roadmap_path: "docs/2026-07-01-roadmap.md",
+      update_home_page: true,
+      source_repository: nil,
+      wiki_clone_url: nil,
+      wiki_branch: "master",
+      force: false,
+      branch: nil,
+      entry_page_name: nil,
+      github_host: "https://github.com",
+      git_user_name: "github-actions[bot]",
+      git_user_email: "github-actions[bot]@users.noreply.github.com",
+      command_runner: nil,
+      capture_runner: nil,
+      input: $stdin,
+      output: $stdout,
+      interactive: nil
+    )
+      @docs_path = docs_path
+      @wiki_repository = wiki_repository ? normalize_wiki_repository(wiki_repository) : nil
+      @wiki_deploy_token = wiki_deploy_token
+      @output_dir = output_dir
+      @wiki_checkout = wiki_checkout
+      @roadmap_path = roadmap_path
+      @update_home_page = update_home_page
+      @source_repository = source_repository || (wiki_repository ? source_repository_from_wiki : nil)
+      @wiki_clone_url = wiki_clone_url
+      @wiki_branch = wiki_branch
+      @force = force
+      @branch = branch
+      @github_host = (github_host.nil? || github_host.to_s.strip.empty?) ? "https://github.com" : github_host.to_s.sub(%r{/+\z}, "")
+      @git_user_name = git_user_name
+      @git_user_email = git_user_email
+      @command_runner = command_runner
+      @capture_runner = capture_runner
+      @input = input
+      @output = output
+      @interactive = interactive
+      @migrator = Migrator.new(docs_path, entry_page_name: entry_page_name)
+      @entry_url = @source_repository ? build_entry_url : nil
+    end
+
+    def self.from_env(docs_path)
+      new(
+        docs_path: docs_path,
+        wiki_repository: ENV["WIKI_REPOSITORY"] || ENV["WIKI_REPO"],
+        wiki_deploy_token: ENV["WIKI_DEPLOY_TOKEN"],
+        output_dir: ENV["WIKI_OUTPUT_DIR"] || File.join("tmp", "wiki-migration"),
+        wiki_checkout: ENV["WIKI_CHECKOUT_DIR"] || File.join("tmp", "wiki-checkout"),
+        roadmap_path: ENV["ROADMAP_PATH"] || "docs/2026-07-01-roadmap.md",
+        update_home_page: truthy_env?("UPDATE_HOME_PAGE", default: true),
+        source_repository: ENV["SOURCE_REPOSITORY"] || ENV["GITHUB_REPOSITORY"],
+        wiki_clone_url: ENV["WIKI_CLONE_URL"],
+        wiki_branch: ENV["WIKI_BRANCH"] || "master",
+        force: ENV["WIKI_FORCE"] == "1" || ENV["WIKI_FORCE"] == "true",
+        branch: ENV["GITHUB_REF_NAME"],
+        entry_page_name: ENV["ENTRY_PAGE_NAME"].then { |value| blank?(value) ? nil : value },
+        github_host: ENV["GITHUB_SERVER_URL"] || "https://github.com",
+        git_user_name: ENV["GIT_USER_NAME"] || "github-actions[bot]",
+        git_user_email: ENV["GIT_USER_EMAIL"] || "github-actions[bot]@users.noreply.github.com"
+      )
+    end
+
+    def self.truthy_env?(name, default:)
+      value = ENV[name]
+      return default if blank?(value)
+
+      !%w[0 false no off].include?(value.downcase)
+    end
+
+    def self.blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    def migrate
+      FileUtils.rm_rf(output_dir)
+      FileUtils.mkdir_p(output_dir)
+
+      validate_non_markdown_files!
+
+      pages = migrator.pages
+      pages.each do |filename, content|
+        File.write(File.join(output_dir, filename), content)
+      end
+
+      non_markdown_files.each do |file|
+        rel = relative_path(file)
+        target = File.join(output_dir, rel)
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp(file, target)
+      end
+
+      pages
+    end
+
+    def publish
+      raise ArgumentError, "wiki_repository required to publish" if blank?(@wiki_repository)
+      raise ArgumentError, "wiki_deploy_token required to publish" if blank?(@wiki_deploy_token)
+
+      # Prevent git from prompting for credentials on a local TTY and hanging.
+      ENV["GIT_TERMINAL_PROMPT"] = "0"
+
+      pages = migrate
+      configure_git(".")
+      clone_or_update_wiki
+      configure_git(wiki_checkout)
+      copy_all_files_to_wiki
+      add_home_index_entry if @update_home_page
+      # Prove we can push the source-branch cleanup before we make the
+      # irreversible wiki push, so a permissions/connectivity problem aborts
+      # while both remotes are still untouched rather than after the wiki is
+      # updated but the branch cleanup can't land.
+      verify_source_push_access if Dir.exist?(docs_path)
+      commit_and_push_wiki
+      cleanup_source_branch
+
+      PublishResult.new(wiki_url: entry_url, pages: pages)
+    end
+
+    private
+
+    def blank?(value)
+      self.class.blank?(value)
+    end
+
+    def normalize_wiki_repository(repository)
+      normalized = repository.to_s.strip
+      normalized = normalized.sub(%r{\Ahttps://github\.com/}, "")
+      normalized = normalized.sub(%r{\.git\z}, "")
+      normalized = normalized.sub(%r{/+\z}, "")
+      normalized.end_with?(".wiki") ? normalized : "#{normalized}.wiki"
+    end
+
+    def source_repository_from_wiki
+      @wiki_repository.sub(/\.wiki\z/, "")
+    end
+
+    def build_entry_url
+      wiki_page_url(migrator.entry_wiki_name)
+    end
+
+    def wiki_page_url(wiki_name)
+      "#{@github_host}/#{@source_repository}/wiki/#{wiki_name.tr(" ", "-")}"
+    end
+
+    # {source_file_path => its own flattened wiki URL} for every page in the
+    # tree, used to repoint roadmap deep links at the specific sub-page rather
+    # than collapsing everything onto the entry page.
+    def page_urls
+      return {} unless @source_repository
+
+      migrator.wiki_names.each_with_object({}) do |(rel, wiki_name), memo|
+        memo[File.join(docs_path, rel)] = wiki_page_url(wiki_name)
+      end
+    end
+
+    def clone_url
+      @wiki_clone_url || "https://x-access-token:#{@wiki_deploy_token}@github.com/#{@wiki_repository}.git"
+    end
+
+    def clone_or_update_wiki
+      if Dir.exist?(File.join(wiki_checkout, ".git"))
+        # Re-point origin to the current clone_url so a rotated token takes
+        # effect on an existing checkout (the origin URL is frozen at first
+        # clone and credential helpers are disabled).
+        run("git", "-C", wiki_checkout, "remote", "set-url", "origin", clone_url)
+        run("git", "-C", wiki_checkout, "fetch", "origin")
+        run("git", "-C", wiki_checkout, "reset", "--hard", "origin/#{@wiki_branch}")
+      else
+        FileUtils.mkdir_p(File.dirname(wiki_checkout))
+        # Disable credential helpers for the initial clone only; subsequent
+        # fetch/push are covered by configure_git(wiki_checkout) which sets
+        # credential.helper to empty in the local config.
+        run("git", "-c", "credential.helper=", "clone", clone_url, wiki_checkout)
+        run("git", "-C", wiki_checkout, "checkout", "-B", @wiki_branch, "origin/#{@wiki_branch}")
+      end
+    end
+
+    def configure_git(repository_path)
+      return if blank?(@git_user_name) || blank?(@git_user_email)
+
+      run("git", "-C", repository_path, "config", "user.name", @git_user_name)
+      run("git", "-C", repository_path, "config", "user.email", @git_user_email)
+      run("git", "-C", repository_path, "config", "commit.gpgsign", "false")
+      run("git", "-C", repository_path, "config", "tag.gpgsign", "false")
+      # Disable credential helpers in the wiki checkout so the token embedded
+      # in the clone URL is used instead of system helpers (osxkeychain, gh)
+      # that may supply different credentials and cause a 403 on push.
+      run("git", "-C", repository_path, "config", "credential.helper", "")
+    end
+
+    def copy_all_files_to_wiki
+      files = Dir.glob(File.join(output_dir, "**", "*")).reject { |p| File.directory?(p) }
+      files.each do |file|
+        rel = Pathname.new(file).relative_path_from(Pathname.new(output_dir)).to_s
+        target = File.join(wiki_checkout, rel)
+
+        if File.exist?(target) && !FileUtils.compare_file(file, target) && !@force
+          raise Error, "Refusing to overwrite existing wiki page with different content: #{rel}. Set WIKI_FORCE=1 to overwrite."
+        end
+
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp(file, target)
+      end
+      run("git", "-C", wiki_checkout, "add", ".")
+    end
+
+    def non_markdown_files
+      Dir.glob(File.join(docs_path, "**", "*"))
+        .reject { |p| File.directory?(p) || p.end_with?(".md") || File.basename(p).start_with?(".") }
+    end
+
+    def validate_non_markdown_files!
+      return if @force
+
+      unsupported = non_markdown_files.select do |file|
+        ext = File.extname(file).downcase
+        !SUPPORTED_EXTENSIONS.include?(ext)
+      end
+
+      return if unsupported.empty?
+
+      message = "Unsupported non-markdown file type(s) found in docs tree: #{unsupported.map { |f| File.basename(f) }.join(", ")}."
+
+      if interactive?
+        @output.print "#{message}\nProceed anyway? (y/N): "
+        response = @input.gets&.chomp
+        unless /\Ay(?:es)?\z/i.match?(response)
+          raise Error, "Aborted by user due to unsupported file types."
+        end
+      else
+        raise Error, "#{message} Use WIKI_FORCE=1, the --force CLI option, or the force action input to override."
+      end
+    end
+
+    def relative_path(path)
+      Pathname.new(path).relative_path_from(Pathname.new(docs_path)).to_s
+    end
+
+    def interactive?
+      return @interactive unless @interactive.nil?
+
+      @input.tty? && !ENV["CI"]
+    end
+
+    def add_home_index_entry
+      home_path = File.join(wiki_checkout, "Home.md")
+      return unless File.exist?(home_path)
+
+      entry_wiki_name = migrator.entry_wiki_name
+      entry_page_path = File.join(output_dir, "#{entry_wiki_name}.md")
+      entry_h1 = migrator.h1(File.read(entry_page_path)) || entry_wiki_name
+      # Em dash matches the heading format used in every hand-authored Home.md
+      # entry so the dedupe guard below actually recognizes existing entries.
+      heading = "## Issue ##{migrator.issue_number} — #{entry_h1}"
+      new_section = <<~SECTION
+        #{heading}
+
+        **Migrated to the wiki.** See [#{entry_h1}](#{WikiPromoter.encode_wiki_link_target(entry_wiki_name)}) for the full research.
+
+      SECTION
+
+      home = File.read(home_path)
+      return if home.include?(heading)
+
+      anchor = "## Settled Decisions"
+      if home.include?(anchor)
+        File.write(home_path, home.sub(anchor, new_section + anchor))
+      else
+        # No anchor heading — append the entry and create the anchor so
+        # future entries insert above it and the layout converges.
+        File.write(home_path, home.sub(/\n*\z/, "\n\n") + new_section + anchor)
+      end
+      run("git", "-C", wiki_checkout, "add", "Home.md")
+    end
+
+    def commit_and_push_wiki
+      return unless staged_changes?(wiki_checkout)
+
+      run("git", "-C", wiki_checkout, "commit", "-m", "Migrate #{docs_path} research to the wiki")
+      run("git", "-C", wiki_checkout, "push", "origin", "HEAD:#{@wiki_branch}")
+    end
+
+    def verify_source_push_access
+      run("git", "push", "--dry-run", "origin", "HEAD:refs/heads/#{source_branch}")
+    end
+
+    def cleanup_source_branch
+      unless Dir.exist?(docs_path)
+        puts "#{docs_path} already removed from this branch; skipping the cleanup commit."
+        return
+      end
+
+      repoint_roadmap
+      run("git", "rm", "-r", "--quiet", docs_path)
+      run("git", "add", @roadmap_path) if File.exist?(@roadmap_path)
+      return unless staged_changes?(".")
+
+      run("git", "commit", "-m", "Migrate #{docs_path} research to the wiki; drop local tree")
+      run("git", "push", "origin", "HEAD:refs/heads/#{source_branch}")
+    end
+
+    def repoint_roadmap
+      return unless File.exist?(@roadmap_path)
+
+      original = File.read(@roadmap_path)
+      updated = WikiPromoter.repoint_references(
+        original,
+        docs_path: docs_path,
+        entry_url: entry_url,
+        repository: @source_repository,
+        page_urls: page_urls,
+        github_host: @github_host
+      )
+      File.write(@roadmap_path, updated) if updated != original
+    end
+
+    def source_branch
+      branch = @branch || capture("git", "symbolic-ref", "-q", "--short", "HEAD").strip
+      raise Error, "Could not determine a branch to push to" if blank?(branch)
+
+      branch
+    end
+
+    def staged_changes?(repository_path)
+      !system("git", "-C", repository_path, "diff", "--cached", "--quiet")
+    end
+
+    def run(*cmd)
+      if @command_runner
+        @command_runner.call(cmd)
+      elsif !system(*cmd)
+        raise Error, "Command failed: #{cmd.join(" ")}"
+      end
+    end
+
+    def capture(*cmd)
+      return @capture_runner.call(cmd) if @capture_runner
+
+      stdout, status = Open3.capture2(*cmd)
+      raise Error, "Command failed: #{cmd.join(" ")}" unless status.success?
+
+      stdout
+    end
+  end
+end

data/lib/wiki_promoter/tasks.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+require_relative "../wiki_promoter"
+
+namespace :wiki do
+  desc "Flatten and relink a docs tree, outputting to tmp/wiki-migration/"
+  task :migrate, [:docs_path] do |_t, args|
+    docs_path = args[:docs_path] || ENV["DOCS_PATH"]
+    raise ArgumentError, "docs_path required (pass as task argument or DOCS_PATH env var)" unless docs_path
+
+    entry_page_name = ENV["ENTRY_PAGE_NAME"]
+
+    migrator = WikiPromoter::Migrator.new(docs_path, entry_page_name: entry_page_name)
+    output_dir = ENV["WIKI_OUTPUT_DIR"] || File.join("tmp", "wiki-migration")
+    FileUtils.rm_rf(output_dir)
+    FileUtils.mkdir_p(output_dir)
+
+    # Write flattened pages
+    migrator.pages.each do |filename, content|
+      path = File.join(output_dir, filename)
+      File.write(path, content)
+      puts "  wrote #{path}"
+    end
+
+    puts "Migration complete: #{migrator.pages.size} files written to #{output_dir}/"
+  end
+
+  desc "Publish docs to wiki, update Home.md, repoint roadmap, and delete source"
+  task :publish, [:docs_path] do |_t, args|
+    docs_path = args[:docs_path] || ENV["DOCS_PATH"]
+    raise ArgumentError, "docs_path required (pass as task argument or DOCS_PATH env var)" unless docs_path
+
+    result = WikiPromoter::Publisher.from_env(docs_path).publish
+    puts "Publishing complete: #{result.wiki_url}"
+  end
+end

data/lib/wiki_promoter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WikiPromoter
+  VERSION = "0.1.0"
+end

data/lib/wiki_promoter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "wiki_promoter/version"
+require_relative "wiki_promoter/migrator"
+require_relative "wiki_promoter/publisher"
+
+module WikiPromoter
+  class Error < StandardError; end
+
+  # Percent-encode a wiki page name for use as a markdown link target.
+  # GitHub wiki renders [text](page name) as plain text when the URL
+  # contains unencoded reserved characters: '#' starts a fragment, '%'
+  # creates invalid escape sequences, '(' ')' break the markdown link
+  # syntax. Encode '%' first to avoid double-encoding.
+  def self.encode_wiki_link_target(wiki_name)
+    wiki_name
+      .gsub("%", "%25")
+      .gsub(" ", "%20")
+      .gsub("#", "%23")
+      .gsub("(", "%28")
+      .gsub(")", "%29")
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: wiki_promoter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- CPB
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: A pure-Ruby gem that automates promoting research/planning documents
+  from a docs/ hierarchy into a GitHub Wiki. Includes Rake tasks for local use and
+  a composite GitHub Action for workflow automation.
+email:
+- cpb@github.com
+executables:
+- wiki-promoter
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- action/action.yml
+- exe/wiki-promoter
+- lib/wiki_promoter.rb
+- lib/wiki_promoter/migrator.rb
+- lib/wiki_promoter/publisher.rb
+- lib/wiki_promoter/tasks.rb
+- lib/wiki_promoter/version.rb
+homepage: https://github.com/cpb/wiki_promoter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Flatten, migrate, and sync GitHub Markdown research trees to GitHub Wiki
+test_files: []