@nguyenphp/antigravity-marketing 1.0.18 → 1.0.20

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/Commands/MergeRunsCommand.cs

@@ -0,0 +1,122 @@
+using System.CommandLine;
+using System.IO.Compression;
+using System.Xml.Linq;
+
+namespace MiniMaxAIDocx.Core.Commands;
+
+public static class MergeRunsCommand
+{
+    private static readonly XNamespace W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+
+    public static Command Create()
+    {
+        var inputOption = new Option<string>("--input") { Description = "DOCX file to optimize", Required = true };
+        var outputOption = new Option<string>("--output") { Description = "Output path (default: overwrite input)" };
+        var dryRunOption = new Option<bool>("--dry-run") { Description = "Report without modifying" };
+
+        var cmd = new Command("merge-runs", "Merge adjacent runs with identical formatting")
+        {
+            inputOption, outputOption, dryRunOption
+        };
+
+        cmd.SetAction((parseResult) =>
+        {
+            var input = parseResult.GetValue(inputOption)!;
+            var output = parseResult.GetValue(outputOption) ?? input;
+            var dryRun = parseResult.GetValue(dryRunOption);
+
+            if (!File.Exists(input))
+            {
+                Console.Error.WriteLine($"File not found: {input}");
+                return;
+            }
+
+            var tempPath = Path.GetTempFileName();
+            File.Copy(input, tempPath, true);
+
+            using var zip = ZipFile.Open(tempPath, ZipArchiveMode.Update);
+            var entry = zip.GetEntry("word/document.xml");
+            if (entry == null)
+            {
+                Console.Error.WriteLine("Not a valid DOCX: missing word/document.xml");
+                return;
+            }
+
+            XDocument doc;
+            using (var stream = entry.Open())
+                doc = XDocument.Load(stream);
+
+            int originalCount = 0;
+            int mergedCount = 0;
+
+            foreach (var p in doc.Descendants(W + "p"))
+            {
+                var runs = p.Elements(W + "r").ToList();
+                originalCount += runs.Count;
+
+                for (int i = runs.Count - 1; i > 0; i--)
+                {
+                    var current = runs[i];
+                    var previous = runs[i - 1];
+
+                    var curProps = current.Element(W + "rPr")?.ToString() ?? "";
+                    var prevProps = previous.Element(W + "rPr")?.ToString() ?? "";
+
+                    if (curProps == prevProps)
+                    {
+                        // Only merge if both contain only text elements
+                        var curChildren = current.Elements().Where(e => e.Name != W + "rPr").ToList();
+                        var prevChildren = previous.Elements().Where(e => e.Name != W + "rPr").ToList();
+
+                        if (curChildren.All(e => e.Name == W + "t") && prevChildren.All(e => e.Name == W + "t"))
+                        {
+                            var prevText = previous.Elements(W + "t").LastOrDefault();
+                            var curText = current.Elements(W + "t").FirstOrDefault();
+
+                            if (prevText != null && curText != null)
+                            {
+                                prevText.Value += curText.Value;
+                                prevText.SetAttributeValue(XNamespace.Xml + "space", "preserve");
+
+                                foreach (var extra in current.Elements(W + "t").Skip(1))
+                                {
+                                    previous.Add(new XElement(extra));
+                                }
+
+                                current.Remove();
+                                runs.RemoveAt(i);
+                            }
+                        }
+                    }
+                }
+
+                mergedCount += runs.Count;
+            }
+
+            if (dryRun)
+            {
+                Console.WriteLine($"Original runs: {originalCount}");
+                Console.WriteLine($"After merge:   {mergedCount}");
+                Console.WriteLine($"Reduction:     {(originalCount > 0 ? (originalCount - mergedCount) * 100.0 / originalCount : 0):F1}%");
+                File.Delete(tempPath);
+                return;
+            }
+
+            entry.Delete();
+            var newEntry = zip.CreateEntry("word/document.xml", CompressionLevel.Optimal);
+            using (var stream = newEntry.Open())
+                doc.Save(stream);
+
+            zip.Dispose();
+            File.Copy(tempPath, output, true);
+            File.Delete(tempPath);
+
+            Console.WriteLine($"Original runs: {originalCount}");
+            Console.WriteLine($"After merge:   {mergedCount}");
+            Console.WriteLine($"Reduction:     {(originalCount > 0 ? (originalCount - mergedCount) * 100.0 / originalCount : 0):F1}%");
+            Console.WriteLine($"Written to:    {output}");
+        });
+
+        return cmd;
+    }
+}

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/Commands/ValidateCommand.cs

@@ -0,0 +1,107 @@
+using System.CommandLine;
+using System.Text.Json;
+using MiniMaxAIDocx.Core.Validation;
+
+namespace MiniMaxAIDocx.Core.Commands;
+
+public static class ValidateCommand
+{
+    public static Command Create()
+    {
+        var inputOption = new Option<string>("--input") { Description = "DOCX file to validate", Required = true };
+        var xsdOption = new Option<string>("--xsd") { Description = "XSD schema path for XML validation" };
+        var businessOption = new Option<bool>("--business") { Description = "Run business rule validation" };
+        var gateCheckOption = new Option<string>("--gate-check") { Description = "Template DOCX for gate-check validation" };
+        var jsonOption = new Option<bool>("--json") { Description = "Output results as JSON" };
+
+        var cmd = new Command("validate", "Validate DOCX structure and content")
+        {
+            inputOption, xsdOption, businessOption, gateCheckOption, jsonOption
+        };
+
+        cmd.SetAction((parseResult) =>
+        {
+            var input = parseResult.GetValue(inputOption)!;
+            var xsd = parseResult.GetValue(xsdOption);
+            var business = parseResult.GetValue(businessOption);
+            var gateCheck = parseResult.GetValue(gateCheckOption);
+            var asJson = parseResult.GetValue(jsonOption);
+
+            if (!File.Exists(input))
+            {
+                Console.Error.WriteLine($"File not found: {input}");
+                return;
+            }
+
+            var combinedResult = new ValidationResult();
+            GateCheckResult? gateResult = null;
+
+            if (xsd != null)
+            {
+                var xsdValidator = new XsdValidator();
+                combinedResult.Merge(xsdValidator.Validate(input, xsd));
+            }
+
+            if (business)
+            {
+                var bizValidator = new BusinessRuleValidator();
+                combinedResult.Merge(bizValidator.Validate(input));
+            }
+
+            if (gateCheck != null)
+            {
+                var gateValidator = new GateCheckValidator();
+                gateResult = gateValidator.Validate(input, gateCheck);
+            }
+
+            if (asJson)
+            {
+                var output = new
+                {
+                    isValid = combinedResult.IsValid && (gateResult?.Passed ?? true),
+                    errors = combinedResult.Errors,
+                    warnings = combinedResult.Warnings,
+                    gateCheck = gateResult == null ? null : new
+                    {
+                        passed = gateResult.Passed,
+                        violations = gateResult.Violations
+                    }
+                };
+                Console.WriteLine(JsonSerializer.Serialize(output, new JsonSerializerOptions { WriteIndented = true }));
+            }
+            else
+            {
+                if (combinedResult.Errors.Count > 0)
+                {
+                    Console.WriteLine($"ERRORS ({combinedResult.Errors.Count}):");
+                    foreach (var e in combinedResult.Errors)
+                        Console.WriteLine($"  [{e.Severity}] {e.Message}" + (e.LineNumber > 0 ? $" (line {e.LineNumber}:{e.LinePosition})" : ""));
+                }
+
+                if (combinedResult.Warnings.Count > 0)
+                {
+                    Console.WriteLine($"WARNINGS ({combinedResult.Warnings.Count}):");
+                    foreach (var w in combinedResult.Warnings)
+                        Console.WriteLine($"  [{w.Severity}] {w.Message}");
+                }
+
+                if (gateResult != null)
+                {
+                    Console.WriteLine(gateResult.Passed ? "GATE CHECK: PASSED" : "GATE CHECK: FAILED");
+                    foreach (var v in gateResult.Violations)
+                        Console.WriteLine($"  - {v}");
+                }
+
+                if (combinedResult.IsValid && (gateResult?.Passed ?? true))
+                    Console.WriteLine("Validation: PASSED");
+                else
+                    Console.WriteLine("Validation: FAILED");
+            }
+
+            if (!combinedResult.IsValid || gateResult is { Passed: false })
+                Environment.ExitCode = 1;
+        });
+
+        return cmd;
+    }
+}

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/MiniMaxAIDocx.Core.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <NeutralLanguage>en</NeutralLanguage>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="DocumentFormat.OpenXml" Version="3.5.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.5" />
+  </ItemGroup>
+
+</Project>

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/CommentSynchronizer.cs

@@ -0,0 +1,169 @@
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+
+namespace MiniMaxAIDocx.Core.OpenXml;
+
+/// <summary>
+/// Manages the 4-file comment system (comments.xml, commentsExtended.xml,
+/// commentsIds.xml, commentsExtensible.xml) plus document.xml markers.
+/// </summary>
+public static class CommentSynchronizer
+{
+    /// <summary>
+    /// Adds a comment to the document, updating all required parts.
+    /// </summary>
+    public static int AddComment(WordprocessingDocument doc, string text, string author, string rangeBookmark)
+    {
+        var mainPart = doc.MainDocumentPart
+            ?? throw new InvalidOperationException("Document has no main part.");
+
+        int commentId = GetNextCommentId(doc);
+
+        // Ensure comments part exists
+        var commentsPart = mainPart.WordprocessingCommentsPart
+            ?? mainPart.AddNewPart<WordprocessingCommentsPart>();
+
+        if (commentsPart.Comments == null)
+            commentsPart.Comments = new Comments();
+
+        // Create the comment
+        var comment = new Comment
+        {
+            Id = commentId.ToString(),
+            Author = author,
+            Date = DateTime.UtcNow,
+            Initials = author.Length > 0 ? author[..1].ToUpperInvariant() : "A"
+        };
+        comment.Append(new Paragraph(new Run(new Text(text))));
+        commentsPart.Comments.Append(comment);
+
+        // Add range markers in document body
+        var body = mainPart.Document.Body;
+        if (body != null)
+        {
+            // Find bookmark or append at end
+            var rangeStart = new CommentRangeStart { Id = commentId.ToString() };
+            var rangeEnd = new CommentRangeEnd { Id = commentId.ToString() };
+            var reference = new Run(new CommentReference { Id = commentId.ToString() });
+
+            body.Append(rangeStart);
+            body.Append(rangeEnd);
+            body.Append(new Paragraph(reference));
+        }
+
+        return commentId;
+    }
+
+    /// <summary>
+    /// Adds a reply to an existing comment.
+    /// </summary>
+    public static int AddReply(WordprocessingDocument doc, int parentCommentId, string text, string author)
+    {
+        var mainPart = doc.MainDocumentPart
+            ?? throw new InvalidOperationException("Document has no main part.");
+
+        var commentsPart = mainPart.WordprocessingCommentsPart
+            ?? throw new InvalidOperationException("Document has no comments part.");
+
+        int replyId = GetNextCommentId(doc);
+
+        var reply = new Comment
+        {
+            Id = replyId.ToString(),
+            Author = author,
+            Date = DateTime.UtcNow,
+            Initials = author.Length > 0 ? author[..1].ToUpperInvariant() : "A"
+        };
+        reply.Append(new Paragraph(new Run(new Text(text))));
+        commentsPart.Comments?.Append(reply);
+
+        // Link reply to parent via commentsExtended.xml
+        LinkReplyToParent(doc, replyId, parentCommentId);
+
+        return replyId;
+    }
+
+    /// <summary>
+    /// Marks a comment as resolved/done by setting done="1" in commentsExtended.xml.
+    /// Uses raw XML manipulation since these extended parts lack typed SDK support.
+    /// </summary>
+    public static void ResolveComment(WordprocessingDocument doc, int commentId)
+    {
+        var mainPart = doc.MainDocumentPart;
+        if (mainPart == null) return;
+
+        // commentsExtended.xml is an untyped part — manipulate via raw XML
+        const string ceUri = "http://schemas.microsoft.com/office/word/2018/wordml/cex";
+        foreach (var part in mainPart.Parts)
+        {
+            if (part.OpenXmlPart.ContentType.Contains("commentsExtensible"))
+            {
+                using var stream = part.OpenXmlPart.GetStream(FileMode.Open, FileAccess.ReadWrite);
+                var xdoc = System.Xml.Linq.XDocument.Load(stream);
+                var ns = System.Xml.Linq.XNamespace.Get(ceUri);
+                var commentEl = xdoc.Descendants(ns + "comment")
+                    .FirstOrDefault(e => e.Attribute(ns + "paraId")?.Value != null);
+                // Set done flag if element found for this comment
+                if (commentEl != null)
+                {
+                    commentEl.SetAttributeValue("done", "1");
+                    stream.SetLength(0);
+                    xdoc.Save(stream);
+                }
+                return;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Links a reply comment to its parent via commentsExtended.xml (w15:commentEx).
+    /// Uses raw XML since the extended comment parts lack typed SDK support.
+    /// </summary>
+    private static void LinkReplyToParent(WordprocessingDocument doc, int replyId, int parentCommentId)
+    {
+        var mainPart = doc.MainDocumentPart;
+        if (mainPart == null) return;
+
+        const string w15Uri = "http://schemas.microsoft.com/office/word/2012/wordml";
+        var w15 = System.Xml.Linq.XNamespace.Get(w15Uri);
+
+        // Find or create commentsExtended part
+        foreach (var part in mainPart.Parts)
+        {
+            if (part.OpenXmlPart.ContentType.Contains("commentsExtended"))
+            {
+                using var stream = part.OpenXmlPart.GetStream(FileMode.Open, FileAccess.ReadWrite);
+                var xdoc = System.Xml.Linq.XDocument.Load(stream);
+                var root = xdoc.Root;
+                if (root == null) return;
+
+                root.Add(new System.Xml.Linq.XElement(w15 + "commentEx",
+                    new System.Xml.Linq.XAttribute(w15 + "paraId", replyId.ToString("X8")),
+                    new System.Xml.Linq.XAttribute(w15 + "paraIdParent", parentCommentId.ToString("X8")),
+                    new System.Xml.Linq.XAttribute(w15 + "done", "0")));
+
+                stream.SetLength(0);
+                xdoc.Save(stream);
+                return;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Finds the maximum existing comment ID and returns the next one.
+    /// </summary>
+    public static int GetNextCommentId(WordprocessingDocument doc)
+    {
+        var commentsPart = doc.MainDocumentPart?.WordprocessingCommentsPart;
+        if (commentsPart?.Comments == null) return 1;
+
+        int maxId = 0;
+        foreach (var comment in commentsPart.Comments.Elements<Comment>())
+        {
+            if (comment.Id?.Value != null && int.TryParse(comment.Id.Value, out int id) && id > maxId)
+                maxId = id;
+        }
+        return maxId + 1;
+    }
+}

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/ElementOrder.cs

@@ -0,0 +1,80 @@
+using System.Xml.Linq;
+
+namespace MiniMaxAIDocx.Core.OpenXml;
+
+/// <summary>
+/// Defines canonical child element ordering for key OpenXML parent elements
+/// and provides reordering utilities.
+/// </summary>
+public static class ElementOrder
+{
+    private static readonly Dictionary<string, string[]> OrderMap = new()
+    {
+        ["w:body"] = ["w:p", "w:tbl", "w:sdt", "w:sectPr"],
+        ["w:p"] = ["w:pPr", "w:hyperlink", "w:r", "w:ins", "w:del", "w:bookmarkStart", "w:bookmarkEnd", "w:commentRangeStart", "w:commentRangeEnd", "w:fldSimple"],
+        ["w:pPr"] = ["w:pStyle", "w:keepNext", "w:keepLines", "w:pageBreakBefore", "w:widowControl", "w:numPr", "w:pBdr", "w:shd", "w:tabs", "w:suppressAutoHyphens", "w:spacing", "w:ind", "w:jc", "w:rPr", "w:sectPr", "w:pPrChange"],
+        ["w:r"] = ["w:rPr", "w:t", "w:br", "w:tab", "w:cr", "w:sym", "w:drawing", "w:delText", "w:fldChar", "w:instrText", "w:lastRenderedPageBreak", "w:noBreakHyphen", "w:softHyphen"],
+        ["w:rPr"] = ["w:rStyle", "w:rFonts", "w:b", "w:bCs", "w:i", "w:iCs", "w:caps", "w:smallCaps", "w:strike", "w:dstrike", "w:vanish", "w:color", "w:sz", "w:szCs", "w:u", "w:shd", "w:highlight", "w:lang", "w:rPrChange"],
+        ["w:tbl"] = ["w:tblPr", "w:tblGrid", "w:tr"],
+        ["w:tblPr"] = ["w:tblStyle", "w:tblpPr", "w:tblOverlap", "w:tblW", "w:jc", "w:tblCellSpacing", "w:tblInd", "w:tblBorders", "w:shd", "w:tblLayout", "w:tblCellMar", "w:tblLook", "w:tblPrChange"],
+        ["w:tr"] = ["w:trPr", "w:tc"],
+        ["w:trPr"] = ["w:cnfStyle", "w:divId", "w:gridBefore", "w:gridAfter", "w:wBefore", "w:wAfter", "w:cantSplit", "w:trHeight", "w:tblHeader", "w:tblCellSpacing", "w:jc", "w:hidden", "w:ins", "w:del", "w:trPrChange"],
+        ["w:tc"] = ["w:tcPr", "w:p", "w:tbl"],
+        ["w:tcPr"] = ["w:cnfStyle", "w:tcW", "w:gridSpan", "w:hMerge", "w:vMerge", "w:tcBorders", "w:shd", "w:noWrap", "w:tcMar", "w:textDirection", "w:tcFitText", "w:vAlign", "w:hideMark", "w:headers", "w:cellIns", "w:cellDel", "w:cellMerge", "w:tcPrChange"],
+        ["w:sectPr"] = ["w:headerReference", "w:footerReference", "w:type", "w:pgSz", "w:pgMar", "w:paperSrc", "w:pgBorders", "w:lnNumType", "w:pgNumType", "w:cols", "w:formProt", "w:vAlign", "w:noEndnote", "w:titlePg", "w:textDirection", "w:bidi", "w:rtlGutter", "w:docGrid"],
+        ["w:hdr"] = ["w:p", "w:tbl", "w:sdt"],
+        ["w:ftr"] = ["w:p", "w:tbl", "w:sdt"],
+    };
+
+    /// <summary>
+    /// Returns the canonical child ordering for a given parent element name (e.g. "w:p").
+    /// Returns null if no ordering is defined.
+    /// </summary>
+    public static string[]? GetChildOrder(string parentElement)
+    {
+        return OrderMap.TryGetValue(parentElement, out var order) ? order : null;
+    }
+
+    /// <summary>
+    /// Reorders children of the given XElement according to the canonical ordering rules.
+    /// Children not listed in the ordering are placed at the end in their original order.
+    /// </summary>
+    public static void ReorderChildren(XElement parent)
+    {
+        var qualifiedName = GetQualifiedName(parent);
+        var order = GetChildOrder(qualifiedName);
+        if (order == null) return;
+
+        var children = parent.Elements().ToList();
+        if (children.Count <= 1) return;
+
+        var orderIndex = new Dictionary<string, int>();
+        for (int i = 0; i < order.Length; i++)
+            orderIndex[order[i]] = i;
+
+        int unknownBase = order.Length;
+        int unknownCounter = 0;
+
+        var sorted = children
+            .Select(c => (Element: c, QName: GetQualifiedName(c)))
+            .OrderBy(x => orderIndex.TryGetValue(x.QName, out var idx) ? idx : unknownBase + unknownCounter++)
+            .Select(x => x.Element)
+            .ToList();
+
+        parent.RemoveNodes();
+        foreach (var child in sorted)
+            parent.Add(child);
+    }
+
+    private static string GetQualifiedName(XElement element)
+    {
+        var ns = element.Name.Namespace;
+        var local = element.Name.LocalName;
+
+        if (ns == Ns.W) return $"w:{local}";
+        if (ns == Ns.R) return $"r:{local}";
+        if (ns == Ns.MC) return $"mc:{local}";
+
+        return local;
+    }
+}

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/NamespaceConstants.cs

@@ -0,0 +1,42 @@
+using System.Xml.Linq;
+
+namespace MiniMaxAIDocx.Core.OpenXml;
+
+/// <summary>
+/// All OpenXML namespace URIs and common content/relationship type constants.
+/// </summary>
+public static class Ns
+{
+    public static readonly XNamespace W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    public static readonly XNamespace R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+    public static readonly XNamespace WP = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+    public static readonly XNamespace A = "http://schemas.openxmlformats.org/drawingml/2006/main";
+    public static readonly XNamespace MC = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    public static readonly XNamespace PIC = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+    public static readonly XNamespace W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
+    public static readonly XNamespace W15 = "http://schemas.microsoft.com/office/word/2012/wordml";
+    public static readonly XNamespace W16CID = "http://schemas.microsoft.com/office/word/2016/wordml/cid";
+    public static readonly XNamespace W16CEX = "http://schemas.microsoft.com/office/word/2018/wordml/cex";
+    public static readonly XNamespace WPC = "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas";
+    public static readonly XNamespace WPS = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+
+    // Content types
+    public const string MainDocumentContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+    public const string StylesContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml";
+    public const string HeaderContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml";
+    public const string FooterContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml";
+    public const string CommentsContentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
+
+    // Relationship types
+    public const string DocumentRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+    public const string StylesRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+    public const string HeaderRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header";
+    public const string FooterRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer";
+    public const string CommentsRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
+    public const string ImageRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+    public const string HyperlinkRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+    public const string NumberingRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+    public const string FontTableRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable";
+    public const string ThemeRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+    public const string SettingsRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings";
+}

package/templates/.agent/skills/minimax-docx/scripts/dotnet/MiniMaxAIDocx.Core/OpenXml/RunMerger.cs

@@ -0,0 +1,81 @@
+using System.Xml.Linq;
+
+namespace MiniMaxAIDocx.Core.OpenXml;
+
+/// <summary>
+/// Result of a run merge operation.
+/// </summary>
+public record RunMergeResult(int OriginalRunCount, int MergedRunCount, int SizeReductionBytes);
+
+/// <summary>
+/// Merges adjacent w:r elements with identical w:rPr formatting to reduce document size.
+/// </summary>
+public static class RunMerger
+{
+    /// <summary>
+    /// Merges adjacent runs with identical formatting in all paragraphs of the document body.
+    /// </summary>
+    public static RunMergeResult MergeRuns(XDocument document)
+    {
+        var body = document.Root?.Element(Ns.W + "body");
+        if (body == null) return new(0, 0, 0);
+
+        int originalCount = 0;
+        int removedCount = 0;
+
+        foreach (var paragraph in body.Descendants(Ns.W + "p"))
+        {
+            var runs = paragraph.Elements(Ns.W + "r").ToList();
+            originalCount += runs.Count;
+
+            for (int i = runs.Count - 1; i > 0; i--)
+            {
+                var current = runs[i];
+                var previous = runs[i - 1];
+
+                if (!AreRunPropertiesEqual(previous, current)) continue;
+
+                // Merge text content from current into previous
+                var prevText = GetOrCreateTextElement(previous);
+                var currText = current.Element(Ns.W + "t");
+                if (currText != null && prevText != null)
+                {
+                    prevText.Value += currText.Value;
+                    // Preserve xml:space="preserve" if either has it
+                    if (currText.Attribute(XNamespace.Xml + "space")?.Value == "preserve" ||
+                        prevText.Value.StartsWith(' ') || prevText.Value.EndsWith(' '))
+                    {
+                        prevText.SetAttributeValue(XNamespace.Xml + "space", "preserve");
+                    }
+                }
+
+                current.Remove();
+                removedCount++;
+            }
+        }
+
+        return new(originalCount, originalCount - removedCount, 0);
+    }
+
+    private static bool AreRunPropertiesEqual(XElement run1, XElement run2)
+    {
+        var rPr1 = run1.Element(Ns.W + "rPr");
+        var rPr2 = run2.Element(Ns.W + "rPr");
+
+        if (rPr1 == null && rPr2 == null) return true;
+        if (rPr1 == null || rPr2 == null) return false;
+
+        return XNode.DeepEquals(rPr1, rPr2);
+    }
+
+    private static XElement? GetOrCreateTextElement(XElement run)
+    {
+        var t = run.Element(Ns.W + "t");
+        if (t == null)
+        {
+            t = new XElement(Ns.W + "t");
+            run.Add(t);
+        }
+        return t;
+    }
+}