@nguyenphp/antigravity-marketing 1.0.18 → 1.0.20

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

@@ -0,0 +1,147 @@
+using System.CommandLine;
+using System.IO.Compression;
+using System.Text.Json;
+using System.Xml.Linq;
+
+namespace MiniMaxAIDocx.Core.Commands;
+
+public static class AnalyzeCommand
+{
+    private static readonly XNamespace W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    private static readonly XNamespace WP = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+
+    public static Command Create()
+    {
+        var inputOption = new Option<string>("--input") { Description = "DOCX file to analyze", Required = true };
+        var jsonOption = new Option<bool>("--json") { Description = "Output as JSON" };
+
+        var cmd = new Command("analyze", "Analyze document structure and styles")
+        {
+            inputOption, jsonOption
+        };
+
+        cmd.SetAction((parseResult) =>
+        {
+            var input = parseResult.GetValue(inputOption)!;
+            var asJson = parseResult.GetValue(jsonOption);
+
+            if (!File.Exists(input))
+            {
+                Console.Error.WriteLine($"File not found: {input}");
+                return;
+            }
+
+            using var zip = ZipFile.OpenRead(input);
+            var docEntry = zip.GetEntry("word/document.xml");
+            if (docEntry == null)
+            {
+                Console.Error.WriteLine("Not a valid DOCX");
+                return;
+            }
+
+            XDocument doc;
+            using (var stream = docEntry.Open())
+                doc = XDocument.Load(stream);
+
+            var body = doc.Root?.Element(W + "body");
+            if (body == null) return;
+
+            // Sections
+            var sections = body.Descendants(W + "sectPr").ToList();
+            var sectionBreaks = sections.Select(s => (string?)s.Element(W + "type")?.Attribute(W + "val") ?? "nextPage").ToList();
+
+            // Headings
+            var headings = new List<object>();
+            foreach (var p in body.Descendants(W + "p"))
+            {
+                var style = (string?)p.Element(W + "pPr")?.Element(W + "pStyle")?.Attribute(W + "val");
+                if (style?.StartsWith("Heading", StringComparison.OrdinalIgnoreCase) == true)
+                {
+                    var text = string.Concat(p.Descendants(W + "t").Select(t => t.Value));
+                    headings.Add(new { style, text });
+                }
+            }
+
+            // Tables
+            var tables = body.Descendants(W + "tbl").Select(tbl => new
+            {
+                rows = tbl.Elements(W + "tr").Count(),
+                cols = tbl.Elements(W + "tr").FirstOrDefault()?.Elements(W + "tc").Count() ?? 0
+            }).ToList();
+
+            // Images
+            var images = body.Descendants(W + "drawing").Count();
+
+            // Headers/footers
+            var headerRefs = sections.SelectMany(s => s.Elements(W + "headerReference")).Count();
+            var footerRefs = sections.SelectMany(s => s.Elements(W + "footerReference")).Count();
+
+            // Paragraphs and word count
+            var paragraphs = body.Descendants(W + "p").ToList();
+            var allText = string.Concat(body.Descendants(W + "t").Select(t => t.Value));
+            var wordCount = allText.Split(new[] { ' ', '\t', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries).Length;
+
+            // XML file sizes
+            var fileSizes = zip.Entries
+                .Where(e => e.FullName.StartsWith("word/") && e.FullName.EndsWith(".xml"))
+                .Select(e => new { file = e.FullName, size = e.Length })
+                .OrderByDescending(e => e.size)
+                .ToList();
+
+            // Styles
+            var styleNames = new List<string>();
+            var stylesEntry = zip.GetEntry("word/styles.xml");
+            if (stylesEntry != null)
+            {
+                using var stream = stylesEntry.Open();
+                var stylesDoc = XDocument.Load(stream);
+                styleNames = stylesDoc.Descendants(W + "style")
+                    .Where(s => (string?)s.Attribute(W + "customStyle") == "1")
+                    .Select(s => (string?)s.Attribute(W + "styleId") ?? "")
+                    .Where(s => s != "")
+                    .ToList();
+            }
+
+            var analysis = new
+            {
+                sections = new { count = sections.Count, breakTypes = sectionBreaks },
+                headings,
+                tables = new { count = tables.Count, details = tables },
+                images,
+                headerFooter = new { headers = headerRefs, footers = footerRefs },
+                paragraphs = paragraphs.Count,
+                estimatedWordCount = wordCount,
+                xmlFileSizes = fileSizes,
+                customStyles = new { count = styleNames.Count, names = styleNames }
+            };
+
+            if (asJson)
+            {
+                Console.WriteLine(JsonSerializer.Serialize(analysis, new JsonSerializerOptions { WriteIndented = true }));
+            }
+            else
+            {
+                Console.WriteLine($"Sections:       {sections.Count} ({string.Join(", ", sectionBreaks)})");
+                Console.WriteLine($"Headings:       {headings.Count}");
+                foreach (var h in headings)
+                    Console.WriteLine($"  {h}");
+                Console.WriteLine($"Tables:         {tables.Count}");
+                foreach (var t in tables)
+                    Console.WriteLine($"  {t.rows} rows x {t.cols} cols");
+                Console.WriteLine($"Images:         {images}");
+                Console.WriteLine($"Headers:        {headerRefs}");
+                Console.WriteLine($"Footers:        {footerRefs}");
+                Console.WriteLine($"Paragraphs:     {paragraphs.Count}");
+                Console.WriteLine($"Word count:     ~{wordCount}");
+                Console.WriteLine($"Custom styles:  {styleNames.Count}");
+                foreach (var s in styleNames)
+                    Console.WriteLine($"  {s}");
+                Console.WriteLine("XML file sizes:");
+                foreach (var f in fileSizes)
+                    Console.WriteLine($"  {f.file}: {f.size:N0} bytes");
+            }
+        });
+
+        return cmd;
+    }
+}

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

@@ -0,0 +1,322 @@
+using System.CommandLine;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+
+namespace MiniMaxAIDocx.Core.Commands;
+
+/// <summary>
+/// Scenario C: Apply formatting from a template DOCX to a source DOCX.
+/// Copies styles, theme, numbering, headers/footers, and section properties
+/// from the template while preserving all content from the source.
+/// </summary>
+public static class ApplyTemplateCommand
+{
+    public static Command Create()
+    {
+        var inputOpt = new Option<string>("--input") { Description = "Source DOCX (content to keep)", Required = true };
+        var templateOpt = new Option<string>("--template") { Description = "Template DOCX (formatting to apply)", Required = true };
+        var outputOpt = new Option<string>("--output") { Description = "Output DOCX file path", Required = true };
+        var applyStylesOpt = new Option<bool>("--apply-styles") { Description = "Copy styles.xml from template" };
+        applyStylesOpt.DefaultValueFactory = _ => true;
+        var applyThemeOpt = new Option<bool>("--apply-theme") { Description = "Copy theme from template" };
+        applyThemeOpt.DefaultValueFactory = _ => true;
+        var applyNumberingOpt = new Option<bool>("--apply-numbering") { Description = "Copy numbering.xml from template" };
+        applyNumberingOpt.DefaultValueFactory = _ => true;
+        var applyHeadersFootersOpt = new Option<bool>("--apply-headers-footers") { Description = "Copy headers/footers from template" };
+        var applySectionsOpt = new Option<bool>("--apply-sections") { Description = "Apply section properties from template" };
+        applySectionsOpt.DefaultValueFactory = _ => true;
+
+        var cmd = new Command("apply-template", "Apply template formatting to a DOCX")
+        {
+            inputOpt, templateOpt, outputOpt, applyStylesOpt, applyThemeOpt,
+            applyNumberingOpt, applyHeadersFootersOpt, applySectionsOpt
+        };
+
+        cmd.SetAction((parseResult) =>
+        {
+            var inputPath = parseResult.GetValue(inputOpt)!;
+            var templatePath = parseResult.GetValue(templateOpt)!;
+            var outputPath = parseResult.GetValue(outputOpt)!;
+            var applyStyles = parseResult.GetValue(applyStylesOpt);
+            var applyTheme = parseResult.GetValue(applyThemeOpt);
+            var applyNumbering = parseResult.GetValue(applyNumberingOpt);
+            var applyHeadersFooters = parseResult.GetValue(applyHeadersFootersOpt);
+            var applySections = parseResult.GetValue(applySectionsOpt);
+
+            if (!File.Exists(inputPath)) { Console.Error.WriteLine($"Input file not found: {inputPath}"); return; }
+            if (!File.Exists(templatePath)) { Console.Error.WriteLine($"Template file not found: {templatePath}"); return; }
+
+            // Create output as a copy of the source
+            File.Copy(inputPath, outputPath, overwrite: true);
+
+            using var output = WordprocessingDocument.Open(outputPath, true);
+            using var template = WordprocessingDocument.Open(templatePath, false);
+
+            var outputMain = output.MainDocumentPart;
+            var templateMain = template.MainDocumentPart;
+            if (outputMain == null || templateMain == null)
+            {
+                Console.Error.WriteLine("Invalid document: missing main document part.");
+                return;
+            }
+
+            int appliedCount = 0;
+
+            if (applyStyles)
+            {
+                CopyStyles(templateMain, outputMain);
+                appliedCount++;
+                Console.WriteLine("  Applied: styles");
+            }
+
+            if (applyTheme)
+            {
+                CopyTheme(templateMain, outputMain);
+                appliedCount++;
+                Console.WriteLine("  Applied: theme");
+            }
+
+            if (applyNumbering)
+            {
+                CopyNumbering(templateMain, outputMain);
+                appliedCount++;
+                Console.WriteLine("  Applied: numbering");
+            }
+
+            if (applyHeadersFooters)
+            {
+                CopyHeadersAndFooters(templateMain, outputMain);
+                appliedCount++;
+                Console.WriteLine("  Applied: headers/footers");
+            }
+
+            if (applySections)
+            {
+                CopySectionProperties(templateMain, outputMain);
+                appliedCount++;
+                Console.WriteLine("  Applied: section properties");
+            }
+
+            outputMain.Document.Save();
+            Console.WriteLine($"Applied {appliedCount} formatting component(s) from template to {outputPath}");
+        });
+
+        return cmd;
+    }
+
+    /// <summary>
+    /// Replaces the output's StyleDefinitionsPart with the template's version.
+    /// </summary>
+    private static void CopyStyles(MainDocumentPart template, MainDocumentPart output)
+    {
+        var templateStyles = template.StyleDefinitionsPart;
+        if (templateStyles == null) return;
+
+        if (output.StyleDefinitionsPart != null)
+            output.DeletePart(output.StyleDefinitionsPart);
+
+        var newStylesPart = output.AddNewPart<StyleDefinitionsPart>();
+
+        using var stream = templateStyles.GetStream(FileMode.Open, FileAccess.Read);
+        newStylesPart.FeedData(stream);
+    }
+
+    /// <summary>
+    /// Replaces the output's ThemePart with the template's version.
+    /// </summary>
+    private static void CopyTheme(MainDocumentPart template, MainDocumentPart output)
+    {
+        var templateTheme = template.ThemePart;
+        if (templateTheme == null) return;
+
+        if (output.ThemePart != null)
+            output.DeletePart(output.ThemePart);
+
+        var newThemePart = output.AddNewPart<ThemePart>();
+
+        using var stream = templateTheme.GetStream(FileMode.Open, FileAccess.Read);
+        newThemePart.FeedData(stream);
+    }
+
+    /// <summary>
+    /// Copies numbering definitions from template, remapping numbering IDs
+    /// referenced in the output document's paragraphs.
+    /// </summary>
+    private static void CopyNumbering(MainDocumentPart template, MainDocumentPart output)
+    {
+        var templateNumbering = template.NumberingDefinitionsPart;
+        if (templateNumbering == null) return;
+
+        var referencedNumIds = new HashSet<string>();
+        var body = output.Document.Body;
+        if (body != null)
+        {
+            foreach (var numId in body.Descendants<NumberingId>())
+            {
+                if (numId.Val?.Value != null)
+                    referencedNumIds.Add(numId.Val.Value.ToString());
+            }
+        }
+
+        if (output.NumberingDefinitionsPart != null)
+            output.DeletePart(output.NumberingDefinitionsPart);
+
+        var newNumberingPart = output.AddNewPart<NumberingDefinitionsPart>();
+
+        using var stream = templateNumbering.GetStream(FileMode.Open, FileAccess.Read);
+        newNumberingPart.FeedData(stream);
+
+        if (referencedNumIds.Count > 0)
+        {
+            Console.WriteLine($"  Note: {referencedNumIds.Count} numbering reference(s) in document content mapped to template definitions.");
+        }
+    }
+
+    /// <summary>
+    /// Copies headers and footers from the template, remapping relationship IDs.
+    /// </summary>
+    private static void CopyHeadersAndFooters(MainDocumentPart template, MainDocumentPart output)
+    {
+        var outputBody = output.Document.Body;
+        if (outputBody == null) return;
+
+        // Remove existing header/footer parts from output
+        foreach (var hp in output.HeaderParts.ToList())
+            output.DeletePart(hp);
+        foreach (var fp in output.FooterParts.ToList())
+            output.DeletePart(fp);
+
+        // Remove existing header/footer references from all section properties
+        foreach (var sectPr in outputBody.Descendants<SectionProperties>())
+        {
+            foreach (var hr in sectPr.Elements<HeaderReference>().ToList())
+                hr.Remove();
+            foreach (var fr in sectPr.Elements<FooterReference>().ToList())
+                fr.Remove();
+        }
+
+        var templateBody = template.Document?.Body;
+        if (templateBody == null) return;
+
+        var templateFinalSectPr = templateBody.Descendants<SectionProperties>().LastOrDefault();
+        if (templateFinalSectPr == null) return;
+
+        var outputFinalSectPr = outputBody.Descendants<SectionProperties>().LastOrDefault();
+        if (outputFinalSectPr == null)
+        {
+            outputFinalSectPr = new SectionProperties();
+            outputBody.Append(outputFinalSectPr);
+        }
+
+        // Copy headers
+        foreach (var headerRef in templateFinalSectPr.Elements<HeaderReference>())
+        {
+            var templateHeaderPart = template.GetPartById(headerRef.Id!) as HeaderPart;
+            if (templateHeaderPart == null) continue;
+
+            var newHeaderPart = output.AddNewPart<HeaderPart>();
+            using (var stream = templateHeaderPart.GetStream(FileMode.Open, FileAccess.Read))
+            {
+                newHeaderPart.FeedData(stream);
+            }
+
+            CopyPartRelationships(templateHeaderPart, newHeaderPart);
+
+            var newRefId = output.GetIdOfPart(newHeaderPart);
+            outputFinalSectPr.InsertAt(new HeaderReference
+            {
+                Type = headerRef.Type,
+                Id = newRefId
+            }, 0);
+        }
+
+        // Copy footers
+        foreach (var footerRef in templateFinalSectPr.Elements<FooterReference>())
+        {
+            var templateFooterPart = template.GetPartById(footerRef.Id!) as FooterPart;
+            if (templateFooterPart == null) continue;
+
+            var newFooterPart = output.AddNewPart<FooterPart>();
+            using (var stream = templateFooterPart.GetStream(FileMode.Open, FileAccess.Read))
+            {
+                newFooterPart.FeedData(stream);
+            }
+
+            CopyPartRelationships(templateFooterPart, newFooterPart);
+
+            var newRefId = output.GetIdOfPart(newFooterPart);
+            var lastHeaderRef = outputFinalSectPr.Elements<HeaderReference>().LastOrDefault();
+            if (lastHeaderRef != null)
+                lastHeaderRef.InsertAfterSelf(new FooterReference { Type = footerRef.Type, Id = newRefId });
+            else
+                outputFinalSectPr.InsertAt(new FooterReference { Type = footerRef.Type, Id = newRefId }, 0);
+        }
+    }
+
+    /// <summary>
+    /// Copies sub-relationships (images, etc.) from a source part to a target part.
+    /// </summary>
+    private static void CopyPartRelationships(OpenXmlPart source, OpenXmlPart target)
+    {
+        foreach (var rel in source.ExternalRelationships)
+        {
+            target.AddExternalRelationship(rel.RelationshipType, rel.Uri, rel.Id);
+        }
+
+        foreach (var childPart in source.Parts)
+        {
+            try
+            {
+                var contentType = childPart.OpenXmlPart.ContentType;
+                if (contentType.StartsWith("image/"))
+                {
+                    var newChild = target.AddNewPart<ImagePart>(contentType, childPart.RelationshipId);
+                    using var stream = childPart.OpenXmlPart.GetStream(FileMode.Open, FileAccess.Read);
+                    newChild.FeedData(stream);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"[WARN] Skipped non-image embedded part: {ex.Message}");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Copies page size, margins, columns, and document grid from template section properties.
+    /// </summary>
+    private static void CopySectionProperties(MainDocumentPart template, MainDocumentPart output)
+    {
+        var templateBody = template.Document?.Body;
+        var outputBody = output.Document?.Body;
+        if (templateBody == null || outputBody == null) return;
+
+        var templateSectPr = templateBody.Descendants<SectionProperties>().LastOrDefault();
+        if (templateSectPr == null) return;
+
+        var outputSectPr = outputBody.Descendants<SectionProperties>().LastOrDefault();
+        if (outputSectPr == null)
+        {
+            outputSectPr = new SectionProperties();
+            outputBody.Append(outputSectPr);
+        }
+
+        CopyChildElement<PageSize>(templateSectPr, outputSectPr);
+        CopyChildElement<PageMargin>(templateSectPr, outputSectPr);
+        CopyChildElement<Columns>(templateSectPr, outputSectPr);
+        CopyChildElement<DocGrid>(templateSectPr, outputSectPr);
+        CopyChildElement<PageBorders>(templateSectPr, outputSectPr);
+    }
+
+    private static void CopyChildElement<T>(SectionProperties source, SectionProperties target) where T : OpenXmlElement
+    {
+        var sourceElement = source.GetFirstChild<T>();
+        if (sourceElement == null) return;
+
+        var existing = target.GetFirstChild<T>();
+        existing?.Remove();
+
+        target.Append((T)sourceElement.CloneNode(true));
+    }
+}