@fectivnfy112358/minimax-code-web 0.1.0-preview.0 → 0.1.0-preview.3

package/server/assets/skills/docx/scripts/docx_preview.ps1

@@ -0,0 +1,76 @@
+# docx_preview.ps1 — Windows mirror of docx_preview.sh
+# Preview DOCX content as plain text (pandoc preferred, falls back to raw word/document.xml).
+#Requires -Version 5.1
+
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory, Position = 0)]
+    [string]$InputPath
+)
+
+$ErrorActionPreference = 'Stop'
+# Force UTF-8 console code page first (chcp 65001) so child native processes (pandoc, tar.exe)
+# see UTF-8 too. PS-only [Console]::OutputEncoding alone is not enough — child native processes
+# inherit the chcp value, not PS's view of stdout.
+try { & chcp.com 65001 *> $null } catch { }
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+[Console]::InputEncoding  = [System.Text.Encoding]::UTF8
+$OutputEncoding           = [System.Text.UTF8Encoding]::new()
+
+if (-not (Test-Path -LiteralPath $InputPath -PathType Leaf)) {
+    Write-Host "Error: File not found: $InputPath" -ForegroundColor Red
+    exit 1
+}
+
+$resolved = (Resolve-Path -LiteralPath $InputPath).Path
+$item     = Get-Item -LiteralPath $resolved
+$sizeKb   = [math]::Round($item.Length / 1KB, 1)
+$base     = Split-Path -Leaf $resolved
+
+Write-Host "=== DOCX Preview: $base ==="
+Write-Host "File size: ${sizeKb} KB"
+
+if (Get-Command pandoc -ErrorAction SilentlyContinue) {
+    # 2>$null discards pandoc's stderr; capture stdout only.
+    $content = & pandoc -f docx -t plain $resolved 2>$null
+    # pandoc exit 0 = success even when the body is empty (cover-only DOCX). Don't truthy-check $content.
+    if ($LASTEXITCODE -eq 0) {
+        $joined = ($content -join "`n")
+        # Word count: split on whitespace and filter empties
+        $words  = ($joined -split '\s+' | Where-Object { $_ }).Count
+        $pages  = [math]::Ceiling($words / 250)
+        Write-Host "Word count: $words"
+        Write-Host "Estimated pages: $pages"
+        Write-Host "---"
+        Write-Host $joined
+        exit 0
+    }
+    Write-Host "(pandoc invocation failed (exit=$LASTEXITCODE), falling back to raw XML extract)" -ForegroundColor Yellow
+} else {
+    Write-Host "(pandoc not available, falling back to raw XML extract)" -ForegroundColor Yellow
+}
+
+Write-Host "---"
+
+# Fallback: open the .docx (zip) and dump word/document.xml first 100 lines.
+$tmpDir = Join-Path $env:TEMP ("docx-preview-" + [System.IO.Path]::GetRandomFileName())
+New-Item -ItemType Directory -Path $tmpDir -Force | Out-Null
+try {
+    # Prefer tar.exe (Windows 10+) — handles .zip natively, faster than Expand-Archive.
+    if (Get-Command tar.exe -ErrorAction SilentlyContinue) {
+        & tar.exe -xf $resolved -C $tmpDir 'word/document.xml' 2>$null
+    } else {
+        # Expand-Archive needs .zip extension; copy with that extension first.
+        $zipCopy = Join-Path $tmpDir 'doc.zip'
+        Copy-Item -LiteralPath $resolved -Destination $zipCopy
+        Expand-Archive -LiteralPath $zipCopy -DestinationPath $tmpDir -Force
+    }
+    $docXml = Join-Path $tmpDir 'word\document.xml'
+    if (Test-Path -LiteralPath $docXml) {
+        Get-Content -LiteralPath $docXml -TotalCount 100 -Encoding UTF8
+    } else {
+        Write-Host "Could not locate word/document.xml inside the package." -ForegroundColor Red
+    }
+} finally {
+    Remove-Item -LiteralPath $tmpDir -Recurse -Force -ErrorAction SilentlyContinue
+}

package/server/assets/skills/docx/scripts/docx_preview.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage: $(basename "$0") <file.docx>"
+  echo "Preview DOCX content as plain text."
+  exit 1
+}
+
+if [ $# -lt 1 ]; then
+  usage
+fi
+
+INPUT="$1"
+
+if [ ! -f "$INPUT" ]; then
+  echo "Error: File not found: $INPUT"
+  exit 1
+fi
+
+FILE_SIZE=$(du -h "$INPUT" | cut -f1)
+echo "=== DOCX Preview: $(basename "$INPUT") ==="
+echo "File size: $FILE_SIZE"
+
+if command -v pandoc &>/dev/null; then
+  CONTENT=$(pandoc -f docx -t plain "$INPUT" 2>/dev/null)
+  WORD_COUNT=$(echo "$CONTENT" | wc -w | tr -d ' ')
+  EST_PAGES=$(( (WORD_COUNT + 249) / 250 ))
+  echo "Word count: $WORD_COUNT"
+  echo "Estimated pages: $EST_PAGES"
+  echo "---"
+  echo "$CONTENT"
+else
+  echo "(pandoc not available, falling back to raw XML extract)"
+  echo "---"
+  unzip -p "$INPUT" word/document.xml 2>/dev/null | head -100
+fi

package/server/assets/skills/docx/scripts/docx_to_pdf.py

@@ -0,0 +1,87 @@
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional, Sequence
+
+
+def find_tool(*names: str) -> Optional[str]:
+    for name in names:
+        resolved = shutil.which(name)
+        if resolved:
+            return resolved
+    return None
+
+
+def run_checked(command: Sequence[str]) -> None:
+    try:
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except subprocess.CalledProcessError as exc:
+        stderr = exc.stderr.decode("utf-8", errors="replace").strip()
+        detail = f"{' '.join(command)} exited with status {exc.returncode}"
+        if stderr:
+            detail = f"{detail}: {stderr}"
+        raise RuntimeError(detail) from exc
+
+
+def convert_to_pdf(input_path: Path, output_path: Path) -> None:
+    office = find_tool("soffice", "libreoffice")
+    if not office:
+        raise RuntimeError("Missing LibreOffice executable (soffice/libreoffice)")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    temp_pdf = output_path.parent / f"{input_path.stem}.pdf"
+    if temp_pdf.exists():
+        temp_pdf.unlink()
+    if output_path.exists() and output_path != temp_pdf:
+        output_path.unlink()
+
+    with tempfile.TemporaryDirectory(prefix="docx-lo-profile-") as profile_dir:
+        command = [
+            office,
+            f"-env:UserInstallation=file://{profile_dir}",
+            "--headless",
+            "--invisible",
+            "--norestore",
+            "--convert-to",
+            "pdf",
+            "--outdir",
+            str(output_path.parent),
+            str(input_path),
+        ]
+        run_checked(command)
+
+    if not temp_pdf.exists():
+        raise RuntimeError(f"LibreOffice did not produce {temp_pdf.name}")
+
+    if temp_pdf != output_path:
+        temp_pdf.replace(output_path)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Convert a DOCX file into a rendered PDF via LibreOffice.")
+    parser.add_argument("--input", required=True, help="Path to the input .docx file")
+    parser.add_argument("--output", required=True, help="Path to the output .pdf file")
+    args = parser.parse_args()
+
+    input_path = Path(args.input).expanduser().resolve()
+    output_path = Path(args.output).expanduser().resolve()
+
+    if not input_path.exists():
+        raise RuntimeError(f"Input file does not exist: {input_path}")
+    if input_path.suffix.lower() != ".docx":
+        raise RuntimeError("docx_to_pdf.py currently supports .docx only")
+
+    convert_to_pdf(input_path, output_path)
+    print(f"Wrote {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as exc:  # pragma: no cover - CLI error path
+        print(f"docx_to_pdf.py failed: {exc}", file=sys.stderr)
+        raise SystemExit(1)

package/server/assets/skills/docx/scripts/dotnet/MiniMaxAIDocx.Cli/MiniMaxAIDocx.Cli.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <ItemGroup>
+    <ProjectReference Include="..\MiniMaxAIDocx.Core\MiniMaxAIDocx.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.CommandLine" Version="2.0.5" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <NeutralLanguage>en</NeutralLanguage>
+  </PropertyGroup>
+
+</Project>

package/server/assets/skills/docx/scripts/dotnet/MiniMaxAIDocx.Cli/Program.cs

@@ -0,0 +1,18 @@
+using System.CommandLine;
+using MiniMaxAIDocx.Core.Commands;
+
+var rootCommand = new RootCommand("docx: OpenXML document generation and manipulation CLI");
+
+// Scenario commands
+rootCommand.Add(CreateCommand.Create());
+rootCommand.Add(EditContentCommand.Create());
+rootCommand.Add(ApplyTemplateCommand.Create());
+
+// Tool commands
+rootCommand.Add(ValidateCommand.Create());
+rootCommand.Add(MergeRunsCommand.Create());
+rootCommand.Add(FixOrderCommand.Create());
+rootCommand.Add(AnalyzeCommand.Create());
+rootCommand.Add(DiffCommand.Create());
+
+return rootCommand.Parse(args).Invoke();

package/server/assets/skills/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;
+    }
+}