commenter 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99f441f58237864e8ea0bc5c8682f04d2b15757ef1f28c45317f0181d6621fb4
-  data.tar.gz: 0a48406aa86377612a2722455dad5013457a10805da311c74c1fbfb82cccafd7
+  metadata.gz: 90d4268c6a071ae365af24ef05a5c19dcdfd6fe03545c05a84767f91f70dc411
+  data.tar.gz: b44468b6f9cc18e0726c1df1c1433247e8fc19f6ff9fafc4c3f0eff341a21785
 SHA512:
-  metadata.gz: 7c26ede9e2a9e4f5f060c0b8679cc9afcb36214a4c5b1a2f02c15a44cd6671d7b104954f4cf4b6df3df9f3806ab7c4d0418982a75371805c773c90064b82c8b9
-  data.tar.gz: 32dd2e31a603391bef5a112d0b10da62b7c29e249bcc76c3e5456aab939015ff51d21036108c3366743db11e01411a2bd285b7992f1a534009d5d4cc184e9d31
+  metadata.gz: 00d4838eadd5c0751199832ff6401a753b2bc4c27cd94d02f6c0d2bab6392a629c216c6cc350766c0d35920f871b4e2bd74102967460e370ebc15fc005a17e9c
+  data.tar.gz: '09420029845d4e6b776eeb40b726326486a409dd8f0ec33be792dcc193e30f5d5774e99777cd64e85c31a5137a69d2648eac4ab06bde2a5ea93a7d2569d0e90a'

data/.rubocop.yml

@@ -12,3 +12,7 @@ Style/StringLiteralsInInterpolation:
 Metrics/ModuleLength:
   Exclude:
     - "spec/**/*"
+
+Metrics/BlockLength:
+  Exclude:
+    - "spec/**/*"

data/CLAUDE.md

@@ -18,13 +18,23 @@ bin/console                      # interactive prompt
 
 CI (metanorma/ci `generic-rake.yml`) runs `bundle exec rake` on Ruby 3.2/3.4/4.0 across macOS/Ubuntu/Windows. RuboCop offenses fail CI — run `bundle exec rake`, not just rspec, before pushing. `Gemfile.lock` is gitignored; dependencies resolve fresh in CI.
 
-Specs generate XLSX fixtures at runtime via `spec/support/xlsx_builder.rb` (plain rubyzip, no spreadsheet-writing dependency) plus row data in `spec/support/osd_fixtures.rb` — there are no binary fixture files in the repo.
+Specs generate XLSX fixtures at runtime via `spec/support/xlsx_builder.rb` (plain rubyzip, no spreadsheet-writing dependency) plus row data in `spec/support/osd_fixtures.rb` — there are no binary fixture files in the repo. Redline DOCX fixtures are built at runtime via `spec/support/redline_docx_builder.rb` (same approach).
+
+## Release
+
+NEVER bump `lib/commenter/version.rb` by hand and never push tags. Releases go through the GHA workflow, which does the version bump, `v*` tag, and gem push itself:
+
+```sh
+gh workflow run release.yml --ref main -f next_version=X.Y.Z
+```
+
+The version number is the maintainer's decision — ask, never infer it from semver reasoning. PRs are rebase-merged.
 
 ## What this gem does
 
 Converts ISO comment sheets to structured YAML and back, and syncs comments to GitHub issues:
 
-- **Import**: DOCX (ISO 2012-03 balloting template) or XLSX (ISO Online Standards Development exports) → YAML + schema file. Format auto-detected from extension.
+- **Import**: DOCX (ISO 2012-03 balloting template) or XLSX (ISO Online Standards Development exports) → YAML + schema file. Format auto-detected from extension. Redline DOCX with tracked changes is dispatched to `Parser::TrackChangeDocxParser` via `--format redline`.
 - **Fill**: YAML → filled DOCX comment sheet (`data/iso_comment_template_2012-03.docx`), optional status-based cell shading.
 - **GitHub round-trip**: `github-create` makes issues from YAML via Liquid templates; `github-retrieve` pulls `> **OBSERVATION:**` blockquotes from closed issues back into the YAML's observations field.
 
@@ -34,11 +44,12 @@ Plain text only — formulas/images/complex formatting are unsupported (docx gem
 
 Core flow: `Parser` → `CommentSheet` (metadata + `Comment` objects) → YAML / DOCX / GitHub issues.
 
-- `Commenter::Comment` / `Commenter::CommentSheet` — data model. `Comment` carries the common fields plus optional OSD-specific fields (`user_name`, `resolution_status`, `motivation`, etc.) and a `github` sub-hash tracking issue state. The sheet's `version` field (`"2012-03"` vs `"osd"`) selects the output schema.
-- `Commenter::Parser` — dispatches by format: `.docx` parsed inline with the `docx` gem; `.xlsx` delegated to `Parser::OsdXlsxParser` (uses `roo`).
+- `Commenter::Comment` / `Commenter::CommentSheet` — data model. `Comment` carries the common fields plus optional OSD-specific fields (`user_name`, `resolution_status`, `motivation`, etc.) and a `github` sub-hash tracking issue state. Comment types: short codes (`ge`/`te`/`ed`) are expanded to full names (`general`/`technical`/`editorial`) when a `Comment` is loaded; YAML output stores the expanded form. The sheet's `version` field (`"2012-03"` vs `"osd"`) selects the output schema.
+- `Commenter::Parser` — dispatches by format: `.docx` parsed inline with the `docx` gem; `.xlsx` delegated to `Parser::OsdXlsxParser` (uses `roo`); `redline` delegated to `Parser::TrackChangeDocxParser`.
 - `Parser::OsdXlsxParser` — auto-detects two OSD export variants by header row ("resolved" 17-col starting `Comment ID`; "unresolved" 15-col starting `User name`), extracts metadata (date/reference/stage/titles) from header rows 1–2, maps columns by header name into `Comment` attributes, and synthesizes `observations` from `resolution_status` + `motivation`.
-- `Commenter::Filler` — writes comments into the DOCX template table.
-- `Commenter::GitHubIssueCreator` (`lib/commenter/github_integration.rb`) — Octokit-based; duplicate detection searches for a unique ID rendered from a configurable Liquid `unique_id` template (stage-aware by default: `[DIS] GB-001`), so the same comment ID at different ballot stages creates separate issues.
+- `Parser::TrackChangeDocxParser` — redline DOCX import: streams `word/document.xml` with Nokogiri XML::Reader (redlines can exceed 100 MB), captures `w:ins`/`w:del`/`w:moveFrom`/`w:moveTo` as comment entries (`proposed_change` renders the change itself, e.g. `Insert: "text"`; clause resolved from the nearest preceding heading including sub-clauses; element resolved from Table/Figure/Formula/NOTE references in the same clause; self-closing paragraph-mark markers skipped), plus reviewer `w:comment` threads as `-CNNN` remark entries (remark verbatim in `comments`, instruction reworded in `proposed_change`, empty `observations` for the owner). Stamps `observations` from the `observations`/`accept_all` options.
+- `Commenter::Filler` — writes comments into the DOCX template table; maps observation status text (`accept(ed)?`, `noted`, `reject(ed)?`, …) to shading colors.
+- GitHub integration (`lib/commenter/github_integration.rb`) — two classes with parallel structure: `GitHubIssueCreator` (`github-create`) and `GitHubIssueRetriever` (`github-retrieve`). Each loads its own config YAML and Octokit client, and rewrites the comments YAML in place after the run. Duplicate detection searches issue titles for a unique ID rendered from a configurable Liquid `unique_id` template (stage-aware by default: `[DIS] GB-001`), so the same comment ID at different ballot stages creates separate issues.
 - `Commenter::Cli` (`lib/commenter/cli.rb`) — Thor CLI with subcommands `import`, `fill`, `github-create`, `github-retrieve`.
 
 ### Schemas
@@ -55,4 +66,3 @@ Core flow: `Parser` → `CommentSheet` (metadata + `Comment` objects) → YAML /
 - `data/` files (DOCX template, Liquid templates, sample config) are shipped with the gem and loaded relative to `__dir__` — do not treat them as disposable.
 - Testing GitHub integration: use `--dry-run` with `GITHUB_TOKEN=dummy_token` — exercises template rendering without API calls.
 - `sig/commenter.rbs` is a minimal stub; RBS coverage is not currently maintained.
-- Release: pushing a `v*` tag triggers `.github/workflows/release.yml`. Version lives in `lib/commenter/version.rb`.

data/CONTEXT.md

@@ -0,0 +1,27 @@
+# CONTEXT.md — Domain Glossary
+
+The domain language of the commenter gem. Used to name modules and commands;
+keep this current when concepts sharpen.
+
+- **Comment Sheet** — one ballot submission as a whole: metadata (document,
+  stage, date, project, titles) plus its comments. `CommentSheet`.
+- **Comment** — a single remark on a document: identity (id, member body),
+  locality (clause, element, line), type, the remark text, the proposed
+  change, and the disposition (`observations`).
+- **Member Body** — the national body or committee that submitted the comment
+  (`DE`, `US`, `CS` for the ISO/CS secretariat, `**` for ISO itself). A
+  secretariat receives one sheet per member body per ballot.
+- **Ballot** — the set of all comment sheets for one ballot round. Merging
+  member sheets into one is collation; `Ballot`.
+- **Disposition** — the resolution of a comment: accepted, accept with
+  modifications, noted, rejected, or still open. `DispositionStatus` is the
+  single matcher for both free-text observations and OSD's structured
+  `resolution_status`.
+- **Stage** — the ballot stage of the document (WD, CD, DIS, FDIS, PRF, PUB).
+  The same comment ID at different stages is a different comment.
+- **Redline** — a DOCX with tracked changes (`w:ins`/`w:del`/moves), typically
+  from ISO/CS editors; also carries reviewer remark threads.
+- **OSD** — ISO Online Standards Development; its XLSX comment exports come
+  in resolved and unresolved variants.
+- **Unique ID** — stage-aware identity of a comment's GitHub issue
+  (`[DIS] GB-001` by default), used for duplicate detection.

data/README.adoc

@@ -19,6 +19,8 @@ The supported input formats are:
   (DOCX)
 * ISO Online Standards Development (OSD) XLSX exports (resolved and unresolved
   comment sheets)
+* Redlined Word documents containing tracked changes (e.g. ISO/CS editor
+  redlines), imported with `--format redline`
 
 This gem only supports plain text comment extraction and filling. Only use this
 to handle plain text comments and resolutions.
@@ -56,7 +58,9 @@ $ gem install commenter
 === Importing comments
 
 Convert an ISO comment sheet (DOCX or XLSX) to structured YAML.
-The format is auto-detected from the file extension.
+The format is auto-detected from the file extension; redline DOCX must be
+selected explicitly with `--format redline` because the extension cannot
+distinguish a redline from a comment sheet.
 
 [source,shell]
 ----
@@ -68,8 +72,28 @@ $ commenter import "91855-Comments-resolved.xlsx" -o comments.yaml
 
 # From XLSX (ISO OSD comments-only export)
 $ commenter import "ISO 5843-6-Comments.xlsx" -o comments.yaml
+
+# From a redlined DOCX with tracked changes (ISO/CS editor redline)
+$ commenter import "ISO_DIS 2533 Enquiry Trackchange Word.docx" --format redline \
+    --body CS --document "ISO 2533:2026" --stage DIS \
+    --observations "Accepted. ISO/CS tracked change accepted." \
+    -o comments-cs.yaml
 ----
 
+Each tracked change (`w:ins`, `w:del`, `w:moveFrom`, `w:moveTo`) becomes a
+comment entry whose `proposed_change` renders the change itself
+(`Insert: "..."` / `Delete: "..."` / `Move ...: "..."`) and whose
+`locality.clause` is resolved from the nearest preceding heading (including
+sub-clauses such as `4.2.1` and `Annex A`), with `locality.element` resolved
+from the nearest `Table`/`Figure`/`Formula`/`NOTE` reference in the same
+clause. Self-closing paragraph-mark markers are skipped because they carry
+no content.
+
+Reviewer comment threads (`w:comment`) are emitted after the track changes
+with `-CNNN` ids: the remark verbatim in `comments`, its instruction
+reworded as the `proposed_change` (a leading "Please " is dropped), and
+empty `observations` for the document owner to draft.
+
 This will create two files:
 
 `comments.yaml`:: The structured comment data
@@ -87,20 +111,29 @@ Options:
 `-o, --output FILE`:: Output YAML file (default: comments.yaml)
 `-e, --exclude-observations`:: Skip the observations column
 `--schema-dir DIR`:: Directory for schema file (default: schema)
-`--format FORMAT`:: Force input format (`docx` or `xlsx`; auto-detected by default)
-`--sheet NAME`:: XLSX sheet name to parse (default: first sheet)
+`--format FORMAT`:: Force input format (`docx`, `xlsx` or `redline`; auto-detected by default)
+`--sheet NAME`:: XLSX: sheet name to parse (default: first sheet)
 `--resolved-only`:: XLSX: use resolved comments sheet only
 `--unresolved-only`:: XLSX: use unresolved comments sheet only
+`--body CODE`:: Redline: member body code for comment IDs (default: `CS`)
+`--observations TEXT`:: Redline: observations stamped on all track changes
+`--accept-all`:: Redline: stamp `Accepted. Tracked change accepted.` on all track changes (an explicit `--observations` wins)
+`--document ID`:: Redline: document identifier (e.g. `ISO 2533:2026`)
+`--stage STAGE`:: Redline: approval stage (e.g. `DIS`)
 
 ==== Metadata (extraction limitation)
 
 WARNING: Due to a limitation in the underlying `docx` gem, metadata fields
-(Date, Document, Project) from the DOCX header cannot be automatically
-extracted. This is because the required functionality is not yet merged (see
-https://github.com/ruby-docx/docx/pull/73[docx gem PR #73]).
+(Date, Document, Project) cannot yet be automatically extracted from the DOCX
+header during import (see https://github.com/ruby-docx/docx/pull/73[docx gem
+PR #73]). Redline imports take them from the `--document` / `--stage` options;
+for template imports, populate the YAML fields manually.
 
-The generated YAML will have empty metadata fields that you can manually
-populate:
+The reverse direction works: `commenter fill` writes the sheet's
+`date`, `document`, and `project` values into the Date/Document/Project labels
+of the template's page header, so the filled comment sheet is complete.
+
+For template imports, populate the YAML metadata manually:
 
 [source,yaml]
 ----
@@ -113,9 +146,6 @@ project: ""        # Manually add: e.g., "Project name"
 comments:
 ----
 
-Alternatively, you can provide metadata during import using CLI options (planned
-for future release).
-
 
 ==== Example YAML output
 
@@ -134,7 +164,7 @@ comments:
       line_number:
       clause: "_whole document"
       element:
-    type: ge
+    type: general
     comments: |
       The document should include more examples
       to clarify the implementation requirements.
@@ -150,7 +180,7 @@ comments:
       line_number: "45"
       clause: "5.2.1"
       element: "Table 3"
-    type: te
+    type: technical
     comments: |
       The values in Table 3 appear to be
       inconsistent with the formula in 5.1.
@@ -160,11 +190,56 @@ comments:
     observations:
 ----
 
+=== Merging comment sheets (ballot collation)
+
+A secretariat receives one comment file per member body per ballot — mixed
+DOCX templates, OSD XLSX exports, and late redlines that arrive by email.
+`commenter merge` collates them into a single ballot sheet:
+
+[source,shell]
+----
+commenter merge de.yaml us.yaml jp.yaml cs-redline.yaml -o ballot.yaml
+----
+
+Metadata (document, stage, date) is taken from the first sheet that provides
+each field. Comments keep their input order. Identical duplicates of the same
+comment ID are deduplicated silently; the same ID with differing content
+raises an error listing the conflicting IDs — collation stops loudly rather
+than silently dropping a member's comment.
+
+=== Ballot statistics (disposition reports)
+
+Every ballot report needs disposition counts — by member body and overall.
+The data is already in the YAML, so `commenter stats` produces the table:
+
+[source,shell]
+----
+commenter stats ballot.yaml
+----
+
+[source,markdown]
+....
+| Body | Total | Accepted | AWM | Noted | Rejected | TODO | Open | Undecided |
+|------|-------|----------|-----|-------|----------|------|------|-----------|
+| DE   | 12    | 5        | 3   | 2     | 1        | 0    | 0    | 1         |
+| US   | 9     | 4        | 1   | 2     | 1        | 0    | 1    | 0         |
+| **Total** | **21** | **9** | **4** | **4** | **2** | **0** | **1** | **1** |
+
+Comment types: technical 13 · general 5 · editorial 3
+....
+
+A comment's disposition is read from its `observations` text, falling back to
+the OSD `resolution_status` field, then to the GitHub issue state (a still-open
+issue counts as *open*; no disposition at all counts as *undecided*). Use
+`--format yaml` for machine-readable output, and `-o report.md` to write to a
+file — the Markdown pastes directly into a GitHub issue or WG minutes.
+
 === Filling DOCX templates from YAML
 
 This gem contains a command-line utility to fill a DOCX template with comments
 from a YAML file. It generates a filled comment sheet that can be used for
-review and resolution tracking.
+review and resolution tracking. The sheet's `date`, `document`, and `project`
+metadata are written into the template's page header.
 
 The base template is the ISO comment sheet template located at
 `data/iso_comment_template_2012-03.docx`. You can also provide a custom
@@ -471,7 +546,7 @@ comments:
     locality:
       clause: "5.2.1"
       element: "Table 3"
-    type: te
+    type: technical
     comments: "The values in Table 3 appear inconsistent..."
     proposed_change: "Correct the values in column 2..."
     observations: ""
@@ -576,10 +651,10 @@ recognized and applied to the observations column:
 |===
 | Status Pattern | Intended Color | Hex Code | Example
 
+| `awm\|accept(ed)? with (modifications\|changes)` | Olive Green | #C4D79B | "Accepted with modifications"
 | `accept(ed)?` | Green | #92D050 | "Accepted"
-| `awm\|accept with modifications` | Olive Green | #C4D79B | "Accept with modifications"
 | `noted` | Blue | #8DB4E2 | "Noted"
-| `reject(ed)?` | Pink | #FF99CC | "Rejected"
+| `reject(ed)?\|not accepted` | Pink | #FF99CC | "Rejected"
 | `todo` | Diagonal stripes | #D9D9D9 | "TODO: Review"
 
 |===

data/commenter.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "docx", "~> 0.8"
   spec.add_dependency "dotenv", "~> 2.8"
   spec.add_dependency "liquid", "~> 5.0"
+  spec.add_dependency "lutaml-model", "~> 0.8"
   spec.add_dependency "octokit", "~> 6.0"
   spec.add_dependency "roo", ">= 2.10"
   spec.add_dependency "thor", "~> 1.0"

data/lib/commenter/ballot.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Merges member-body comment sheets into a single ballot sheet — the
+  # collation step secretariats otherwise do by hand (ISO's own Comment
+  # Collation Tool fails on non-conforming files).
+  #
+  # Policy: sheet metadata is first-non-nil across the given sheets (the
+  # output version comes from the first sheet); comments keep their input
+  # order. Identical duplicate IDs are deduplicated silently; the same ID
+  # with differing content raises.
+  class Ballot
+    def initialize(sheets)
+      @sheets = sheets
+    end
+
+    def merge
+      CommentSheet.new(
+        version: first_sheet&.version || "2012-03",
+        date: first_value(:date),
+        document: first_value(:document),
+        project: first_value(:project),
+        stage: first_value(:stage),
+        title_en: first_value(:title_en),
+        title_fr: first_value(:title_fr),
+        comments: deduplicate(@sheets.flat_map(&:comments))
+      )
+    end
+
+    private
+
+    def first_sheet
+      @sheets.first
+    end
+
+    def first_value(attribute)
+      @sheets.lazy.map { |sheet| sheet.public_send(attribute) }.find { |value| !value.nil? }
+    end
+
+    def deduplicate(comments)
+      seen = {}
+      conflicts = []
+      kept = comments.reject do |comment|
+        key = comment.id.to_s
+        next false if key.empty?
+
+        existing = seen[key]
+        if existing.nil?
+          seen[key] = comment
+          false
+        elsif identical?(existing, comment)
+          true
+        else
+          conflicts << key
+          false
+        end
+      end
+      return kept if conflicts.empty?
+
+      raise Commenter::Error, "Duplicate comment IDs with differing content: #{conflicts.uniq.sort.join(", ")}"
+    end
+
+    def identical?(one, another)
+      one.comments == another.comments && one.proposed_change == another.proposed_change
+    end
+  end
+end

data/lib/commenter/ballot_report.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Disposition statistics over a comment sheet: the counts ballot reports
+  # need — comments per member body by disposition, and per comment type.
+  module BallotReport
+    module_function
+
+    # status bucket for one comment: matched observation text, else matched
+    # OSD resolution_status, else open when a GitHub issue is still open,
+    # else undecided.
+    def status_for(comment)
+      DispositionStatus.match(comment.observations) ||
+        DispositionStatus.match(comment.resolution_status) ||
+        (comment.github&.status == "open" ? :open : nil) ||
+        (comment.observations.to_s.strip.empty? && comment.resolution_status.to_s.strip.empty? ? :undecided : nil)
+    end
+
+    def counts(comment_sheet)
+      bodies = Hash.new { |hash, body| hash[body] = bucket_hash }
+      types = Hash.new(0)
+      comment_sheet.comments.each do |comment|
+        body = comment.body.to_s.strip.empty? ? "(unknown)" : comment.body
+        bodies[body][:total] += 1
+        status = status_for(comment)
+        bodies[body][status] += 1 if status
+        types[comment.type.to_s.strip.empty? ? "(untyped)" : comment.type] += 1
+      end
+      { total: bodies.values.sum { |bucket| bucket[:total] }, bodies: bodies, types: types }
+    end
+
+    def to_markdown(comment_sheet)
+      data = counts(comment_sheet)
+      sorted_bodies = data[:bodies].sort_by { |body, _| body }
+
+      lines = []
+      lines << "| Body | Total | Accepted | AWM | Noted | Rejected | TODO | Open | Undecided |"
+      lines << "|------|-------|----------|-----|-------|----------|------|------|-----------|"
+      sorted_bodies.each do |body, bucket|
+        lines << "| #{body} | #{bucket[:total]} | #{bucket[:accepted]} | #{bucket[:accept_with_modifications]} | " \
+                 "#{bucket[:noted]} | #{bucket[:rejected]} | #{bucket[:todo]} | #{bucket[:open]} | #{bucket[:undecided]} |"
+      end
+      totals = data[:bodies].values.reduce(bucket_hash) { |sum, bucket| merge_bucket(sum, bucket) }
+      lines << "| **Total** | **#{totals[:total]}** | **#{totals[:accepted]}** | " \
+               "**#{totals[:accept_with_modifications]}** | **#{totals[:noted]}** | " \
+               "**#{totals[:rejected]}** | **#{totals[:todo]}** | **#{totals[:open]}** | **#{totals[:undecided]}** |"
+      lines << ""
+      lines << "Comment types: #{data[:types].sort_by { |type, _| type }.map { |type, count| "#{type} #{count}" }.join(" · ")}"
+      lines.join("\n")
+    end
+
+    def bucket_hash
+      { total: 0, accepted: 0, accept_with_modifications: 0, noted: 0, rejected: 0, todo: 0, open: 0, undecided: 0 }
+    end
+
+    def merge_bucket(sum, bucket)
+      sum.merge(bucket) { |_key, accumulated, addition| accumulated + addition }
+    end
+  end
+end

data/lib/commenter/cli.rb

@@ -3,51 +3,68 @@
 require "thor"
 require "yaml"
 require "fileutils"
-require "commenter/parser"
-require "commenter/filler"
-require "commenter/github_integration"
+require "commenter"
 
 module Commenter
   class Cli < Thor
-    desc "import INPUT", "Convert comment sheet (DOCX or XLSX) to YAML"
+    desc "import INPUT", "Convert comment sheet (DOCX or XLSX) or redline DOCX to YAML"
     option :output, type: :string, aliases: :o, default: "comments.yaml", desc: "Output YAML file"
     option :exclude_observations, type: :boolean, aliases: :e, desc: "Exclude observations column"
     option :schema_dir, type: :string, default: "schema", desc: "Directory for schema file"
-    option :format, type: :string, desc: "Force input format (docx or xlsx)"
+    option :format, type: :string, desc: "Force input format (docx, xlsx or redline)"
     option :sheet, type: :string, desc: "XLSX sheet name to parse (default: first sheet)"
     option :resolved_only, type: :boolean, desc: "XLSX: use resolved comments sheet only"
     option :unresolved_only, type: :boolean, desc: "XLSX: use unresolved comments sheet only"
+    option :body, type: :string, desc: "Redline: member body code for comment IDs (default: CS)"
+    option :observations, type: :string, desc: "Redline: observations stamped on all track changes"
+    option :accept_all, type: :boolean, desc: "Redline: stamp 'Accepted. Tracked change accepted.' on all track changes"
+    option :document, type: :string, desc: "Redline: document identifier (e.g. ISO 2533:2026)"
+    option :stage, type: :string, desc: "Redline: approval stage (e.g. DIS)"
     def import(input_file)
-      output_yaml = options[:output]
-      schema_dir = options[:schema_dir]
-
-      # Ensure schema directory exists
-      FileUtils.mkdir_p(schema_dir) unless Dir.exist?(schema_dir)
-
       # Parse the input file
-      parser = Parser.new
-      comment_sheet = parser.parse(input_file, options)
-
-      # Determine which schema to use based on version
-      schema_name = comment_sheet.version == "osd" ? "iso_comment_osd.yaml" : "iso_comment_2012-03.yaml"
+      comment_sheet = Parser.new.parse(input_file, options)
 
-      # Write the YAML data file with schema reference
-      yaml_content = generate_yaml_with_header(comment_sheet.to_yaml_h, schema_dir, schema_name)
-      File.write(output_yaml, yaml_content)
-
-      # Copy schema file to output directory
-      schema_source = File.join(__dir__, "../../schema/#{schema_name}")
-      schema_target = File.join(schema_dir, schema_name)
+      schema_target = write_sheet(comment_sheet, options[:output], options[:schema_dir])
 
-      # Only copy if source and target are different
-      FileUtils.cp(schema_source, schema_target) unless File.expand_path(schema_source) == File.expand_path(schema_target)
-
-      puts "Converted #{input_file} to #{output_yaml}"
+      puts "Converted #{input_file} to #{options[:output]}"
       puts "  Version: #{comment_sheet.version}"
       puts "  Comments: #{comment_sheet.comments.length}"
       puts "  Schema: #{schema_target}"
     end
 
+    desc "merge INPUT.yaml...", "Merge multiple comment sheets into one ballot sheet"
+    option :output, type: :string, aliases: :o, default: "merged.yaml", desc: "Output YAML file"
+    option :schema_dir, type: :string, default: "schema", desc: "Directory for schema file"
+    def merge(*input_files)
+      raise "At least one input file is required" if input_files.empty?
+
+      sheets = input_files.map { |path| CommentSheet.from_yaml(File.read(path)) }
+      comment_sheet = Ballot.new(sheets).merge
+      write_sheet(comment_sheet, options[:output], options[:schema_dir])
+
+      puts "Merged #{input_files.length} files (#{comment_sheet.comments.length} comments) to #{options[:output]}"
+    end
+
+    desc "stats INPUT.yaml", "Disposition statistics for ballot reports"
+    option :output, type: :string, aliases: :o, desc: "Output file (default: stdout)"
+    option :format, type: :string, default: "markdown", enum: %w[markdown yaml], desc: "Report format"
+    def stats(input_yaml)
+      comment_sheet = CommentSheet.from_yaml(File.read(input_yaml))
+
+      report = if options[:format] == "yaml"
+                 BallotReport.counts(comment_sheet).to_yaml
+               else
+                 BallotReport.to_markdown(comment_sheet)
+               end
+
+      if options[:output]
+        File.write(options[:output], report)
+        puts "Wrote statistics to #{options[:output]}"
+      else
+        puts report
+      end
+    end
+
     desc "fill INPUT.yaml", "Fill DOCX template from YAML comments"
     option :output, type: :string, aliases: :o, default: "filled_comments.docx", desc: "Output DOCX file"
     option :template, type: :string, aliases: :t, desc: "Custom template file"
@@ -55,23 +72,20 @@ module Commenter
     def fill(input_yaml)
       output_docx = options[:output]
 
-      # Load YAML data
-      data = YAML.load_file(input_yaml)
-
-      # Extract comments from the structure
-      comments = if data.is_a?(Hash)
-                   data["comments"] || data[:comments] || []
-                 else
-                   data || []
-                 end
-
+      comment_sheet = CommentSheet.from_yaml(File.read(input_yaml))
+      comments = comment_sheet.comments
       raise "No comments found in YAML file" if comments.empty?
 
       # Use default template if none specified
       template_path = options[:template] || File.join(__dir__, "../../data/iso_comment_template_2012-03.docx")
 
-      # Fill the template
-      Filler.new.fill(template_path, output_docx, comments, options)
+      # Fill the template, including the sheet metadata in the page header
+      fill_options = options.merge(
+        date: comment_sheet.date,
+        document: comment_sheet.document,
+        project: comment_sheet.project
+      ).compact
+      Filler.new.fill(template_path, output_docx, comments, fill_options)
       puts "Filled template to #{output_docx}"
     end
 
@@ -215,10 +229,15 @@ module Commenter
 
     private
 
-    def generate_yaml_with_header(data, schema_dir, schema_name = "iso_comment_2012-03.yaml")
-      schema_path = File.join(schema_dir, schema_name)
-      header = "# yaml-language-server: $schema=#{schema_path}\n\n"
-      header + data.to_yaml
+    def write_sheet(comment_sheet, output_yaml, schema_dir)
+      FileUtils.mkdir_p(schema_dir) unless Dir.exist?(schema_dir)
+      File.write(output_yaml, comment_sheet.to_yaml_document(schema_dir))
+
+      schema_name = comment_sheet.schema_name
+      schema_source = File.join(__dir__, "../../schema/#{schema_name}")
+      schema_target = File.join(schema_dir, schema_name)
+      FileUtils.cp(schema_source, schema_target) unless File.expand_path(schema_source) == File.expand_path(schema_target)
+      schema_target
     end
   end
 end