minimax-docx

Files (74)

• LICENSE
• SKILL.md
• academic_styles.xml · assets/styles/
• corporate_styles.xml · assets/styles/
• default_styles.xml · assets/styles/
• aesthetic-rules.xsd · assets/xsd/
• business-rules.xsd · assets/xsd/
• common-types.xsd · assets/xsd/
• wml-subset.xsd · assets/xsd/
• cjk_typography.md · references/
• cjk_university_template_guide.md · references/
• comments_guide.md · references/
• design_good_bad_examples.md · references/
• design_principles.md · references/
• openxml_element_order.md · references/
• openxml_encyclopedia_part1.md · references/
• openxml_encyclopedia_part2.md · references/
• openxml_encyclopedia_part3.md · references/
• openxml_namespaces.md · references/
• openxml_units.md · references/
• scenario_a_create.md · references/
• scenario_b_edit_content.md · references/
• scenario_c_apply_template.md · references/
• track_changes_guide.md · references/
• troubleshooting.md · references/
• typography_guide.md · references/
• xsd_validation_guide.md · references/
• doc_to_docx.sh · scripts/
• docx_preview.sh · scripts/
• MiniMaxAIDocx.Cli.csproj · scripts/dotnet/MiniMaxAIDocx.Cli/
• Program.cs · scripts/dotnet/MiniMaxAIDocx.Cli/
• AnalyzeCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• ApplyTemplateCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• CreateCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• DiffCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• EditContentCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• FixOrderCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• MergeRunsCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• ValidateCommand.cs · scripts/dotnet/MiniMaxAIDocx.Core/Commands/
• MiniMaxAIDocx.Core.csproj · scripts/dotnet/MiniMaxAIDocx.Core/
• CommentSynchronizer.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• ElementOrder.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• NamespaceConstants.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• RunMerger.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• StyleAnalyzer.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• TrackChangesHelper.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• UnitConverter.cs · scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/
• AestheticRecipeSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• AestheticRecipeSamples_Batch1.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• AestheticRecipeSamples_Batch2.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• AestheticRecipeSamples_Batch3.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• AestheticRecipeSamples_Batch4.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• CharacterFormattingSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• DocumentCreationSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• FieldAndTocSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• FootnoteAndCommentSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• HeaderFooterSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• ImageSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• ListAndNumberingSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• ParagraphFormattingSamples.cs · scripts/dotnet/MiniMaxAIDocx.Core/Samples/
• …and 14 more

SKILL.md (first lines)

# minimax-docx

Create, edit, and format DOCX documents via CLI tools or direct C# scripts built on OpenXML SDK (.NET).

## Setup

**First time:** `bash scripts/setup.sh` (or `powershell scripts/setup.ps1` on Windows, `--minimal` to skip optional deps).

**First operation in session:** `scripts/env_check.sh` — do not proceed if `NOT READY`. (Skip on subsequent operations within the same session.)

## Quick Start: Direct C# Path

When the task requires structural document manipulation (custom styles, complex tables, multi-section layouts, headers/footers, TOC, images), write C# directly instead of wrestling with CLI limitations. Use this scaffold:

```csharp
// File: scripts/dotnet/task.csx  (or a new .cs in a Console project)
// dotnet run --project scripts/dotnet/MiniMaxAIDocx.Cli -- run-script task.csx
#r "nuget: DocumentFormat.OpenXml, 3.2.0"

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:
```bash
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`

```bash
$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:
```bash
$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.

```bash
$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.

From vibeeval/vibecosystem, MIT.

More from vibeeval/vibecosystem