$28

using DocumentFormat.OpenXml;

using DocumentFormat.OpenXml.Packaging;

using DocumentFormat.OpenXml.Wordprocessing;

using var doc = WordprocessingDocument.Create("output.docx", WordprocessingDocumentType.Document);

var mainPart = doc.AddMainDocumentPart();

mainPart.Document = new Document(new Body());

// --- Your logic here ---

// Read the relevant Samples/*.cs file FIRST for tested patterns.

// See Samples/ table in References section below.

**Before writing any C#, read the relevant `Samples/*.cs` file** — they contain compilable, SDK-version-verified patterns. The Samples table in the References section below maps topics to files.

## CLI shorthand

All CLI commands below use `$CLI` as shorthand for:

dotnet run --project scripts/dotnet/MiniMaxAIDocx.Cli --

## Pipeline routing

Route by checking: does the user have an input .docx file?

User task

├─ No input file → Pipeline A: CREATE

│ signals: "write", "create", "draft", "generate", "new", "make a report/proposal/memo"

│ → Read references/scenario_a_create.md

│

└─ Has input .docx

├─ Replace/fill/modify content → Pipeline B: FILL-EDIT

│ signals: "fill in", "replace", "update", "change text", "add section", "edit"

│ → Read references/scenario_b_edit_content.md

│

└─ Reformat/apply style/template → Pipeline C: FORMAT-APPLY

signals: "reformat", "apply template", "restyle", "match this format", "套模板", "排版"

├─ Template is pure style (no content) → C-1: OVERLAY (apply styles to source)

└─ Template has structure (cover/TOC/example sections) → C-2: BASE-REPLACE

(use template as base, replace example content with user content)

→ Read references/scenario_c_apply_template.md

If the request spans multiple pipelines, run them sequentially (e.g., Create then Format-Apply).

## Pre-processing

Convert `.doc` → `.docx` if needed: `scripts/doc_to_docx.sh input.doc output_dir/`

Preview before editing (avoids reading raw XML): `scripts/docx_preview.sh document.docx`

Analyze structure for editing scenarios: `$CLI analyze --input document.docx`

## Scenario A: Create

Read `references/scenario_a_create.md`, `references/typography_guide.md`, and `references/design_principles.md` first. Pick an aesthetic recipe from `Samples/AestheticRecipeSamples.cs` that matches the document type — do not invent formatting values. For CJK, also read `references/cjk_typography.md`.

**Choose your path:**

- **Simple** (plain text, minimal formatting): use CLI — `$CLI create --type report --output out.docx --config content.json`

- **Structural** (custom styles, multi-section, TOC, images, complex tables): write C# directly. Read the relevant `Samples/*.cs` first.

CLI options: `--type` (report|letter|memo|academic), `--title`, `--author`, `--page-size` (letter|a4|legal|a3), `--margins` (standard|narrow|wide), `--header`, `--footer`, `--page-numbers`, `--toc`, `--content-json`.

Then run the **validation pipeline** (below).

## Scenario B: Edit / Fill

Read `references/scenario_b_edit_content.md` first. Preview → analyze → edit → validate.

**Choose your path:**

- **Simple** (text replacement, placeholder fill): use CLI subcommands.

- **Structural** (add/reorganize sections, modify styles, manipulate tables, insert images): write C# directly. Read `references/openxml_element_order.md` and the relevant `Samples/*.cs`.

Available CLI edit subcommands:

- `replace-text --find "X" --replace "Y"`

- `fill-placeholders --data '{"key":"value"}'`

- `fill-table --data table.json`

- `insert-section`, `remove-section`, `update-header-footer`

$CLI edit replace-text --input in.docx --output out.docx --find "OLD" --replace "NEW"

$CLI edit fill-placeholders --input in.docx --output out.docx --data '{"name":"John"}'

Then run the **validation pipeline**. Also run diff to verify minimal changes:

$CLI diff --before in.docx --after out.docx

## Scenario C: Apply Template

Read `references/scenario_c_apply_template.md` first. Preview and analyze both source and template.

$CLI apply-template --input source.docx --template template.docx --output out.docx

For complex template operations (multi-template merge, per-section headers/footers, style merging), write C# directly — see Critical Rules below for required patterns.

Run the **validation pipeline**, then the **hard gate-check**:

$CLI validate --input out.docx --gate-check assets/xsd/business-rules.xsd

Gate-check is a **hard requirement**. Do NOT deliver until it passes. If it fails: diagnose, fix, re-run.

Also diff to verify content preservation: `$CLI diff --before source.docx --after out.docx`

## Validation pipeline

Run after every write operation. For Scenario C the full pipeline is **mandatory**; for A/B it is **recommended** (skip only if the operation was trivially simple).

$CLI merge-runs --input doc.docx # 1. consolidate runs

$CLI validate --input doc.docx --xsd assets/xsd/wml-subset.xsd # 2. XSD structure

$CLI validate --input doc.docx --business # 3. business rules

If XSD fails, auto-repair and retry:

$CLI fix-order --input doc.docx

$CLI validate --input doc.docx --xsd assets/xsd/wml-subset.xsd

If XSD still fails, fall back to business rules + preview:

$CLI validate --input doc.docx --business

scripts/docx_preview.sh doc.docx

Verify: font contamination=0, table count correct, drawing count correct, sectPr count correct