⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.7

docx

eigent-ai@eigent-ai⭐ 15.8k stars· last commit 2d ago· 173 open issues

Use this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files). Triggers include: any mention of \"Word doc\", \"word document\", \".docx\", or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a \"report\", \"memo\", \"letter\", \"template\", or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 15.8k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

[![][image-head]][eigent-site]

[![][image-seperator]][eigent-site]

Eigent: The Open Source Cowork Desktop to Unlock Your Exceptional Productivity

[![][download-shield]][eigent-download] [![][github-star]][eigent-github] [![][social-x-shield]][social-x-link] [![][discord-image]][discord-url] [![Reddit][reddit-image]][reddit-url] [![Wechat][wechat-image]][wechat-url] [![][sponsor-shield]][sponsor-link] [![][built-with-camel]][camel-github] [![][join-us-image]][join-us]

English · Português · 简体中文 · 日本語 · [Official Site][eigent-site] · [Documents][docs-site] · [Feedback][github-issue-link]

Eigent is the open source Cowork desktop application, empowering you to build, manage, and deploy a custom AI workforce that can turn your most complex workflows into automated tasks. As a leading open-source Cowork product, Eigent brings together the best of open-source collaboration and AI-powered automation.

Built on [CAMEL-AI][camel-site]'s acclaimed open-source project, our system introduces a Multi-Agent Workforce that boosts productivity through parallel execution, customization, and privacy protection.

⭐ 100% Open Source - 🥇 Local Deployment - 🏆 MCP Integration

  • ✅ Zero Setup - No technical configuration required
  • ✅ Multi-Agent Coordination - Handle complex multi-agent workflows
  • ✅ Single-Agent Harness - Run focused tasks with one meta agent
  • ✅ Local Deployment
  • ✅ Open Source
  • ✅ Model Agnostic - Support any model of your choice
  • ✅ MCP Integration
  • ✅ Skill Integration
  • ✅ Built-in Browser & Terminal Toolkits
  • ✅ Enterprise Features - SSO, access control, and custom enquiries

[![][image-join-us]][join-us]

TOC

🚀 Getting Started with Open Source Cowork

🔓 Build in Public — Eigent is 100% open source from day one. Every feature, every commit, every decision is transparent. We believe the best AI tools should be built openly with the community, not behind closed doors.

🏠 Local Deployment (Recommended)

The recommended way to run Eigent — fully standalone with complete control over your data, no cloud account required.

👉 Full Local Deployment Guide

This setup includes:

  • Local backend server with full API
  • Local model integration (vLLM, Ollama, LM Studio, etc.)
  • Complete isolation from cloud services
  • Zero external dependencies

⚡ Quick Start (Cloud-Connected)

For a quick preview using our cloud backend — get started in seconds:

Prerequisites

  • Node.js (version 18-22) and npm

Steps

git clone https://github.com/eigent-ai/eigent.git
cd eigent
npm install
npm run dev

Note: This mode connects to Eigent cloud services and requires account registration. For a fully standalone experience, use Local Deployment instead.

Updating Dependencies

After pulling new code (git pull), update both frontend and backend dependencies:

# 1. Update frontend dependencies (in project root)
npm install

# 2. Update backend/Python dependencies (in backend directory)
cd backend
uv sync

🏢 Enterprise

For organizations requiring maximum security, customization, and control:

  • Exclusive Features (like SSO & custom development)
  • Scalable Enterprise Deployment
  • Negotiated SLAs & implementation services

📧 For further details, contact our sales team.

☁️ Cloud Version

For teams who prefer managed infrastructure, we also offer a cloud platform. The fastest way to experience Eigent's multi-agent AI capabilities without setup complexity. We'll host the models, APIs, and cloud storage, ensuring Eigent runs flawlessly.

  • Instant Access - Start building multi-agent workflows in minutes.
  • Managed Infrastructure - We handle scaling, updates, and maintenance.
  • Premium Support - Subscribe and get priority assistance from our engineering team.

[![image-public-beta]][eigent-download]

✨ Key features - Open Source Cowork

🧑‍💻 Cowork with Single Agent

Start with one focused agent for direct tasks. Research, write, debug, and operate alongside it in your desktop workspace.

🏭 Cowork with Workforce

Scale to multiple specialized agents that divide work, collaborate in parallel, and execute complex multi-step workflows together.

⏰ Automation

Schedule recurring workflows and let agents run tasks at the right time—so work continues even when you step away.

🔒 Local & Secure

Run agents on your machine with local-first execution. Your files, credentials, and context stay under your control.

🧠 Model Agnostic

Connect the models you already use—cloud APIs, enterprise gateways, or local inference—without locking into one vendor.

👐 100% Open Source

Eigent is completely open-sourced. You can download, inspect, and modify the code, ensuring transparency and fostering a community-driven ecosystem for multi-agent innovation.

🧩 Use Cases - Open Source Cowork

Explore how Eigent turns complex desktop work into repeatable agent workflows.

For Developers

Build 10 Chinese New Year HTML5 Games with Eigent

Coordinate parallel agents to build ten polished, mobile-friendly browser games across genres, complete with scoring, increasing difficulty, and restart flows.

View demo →

View guide →

Build a 3D Snow Bros Platformer with Gemini 3.1 Pro

Create a complete browser-based 3D platformer with snowball combat, enemy chains, scoring, lives, scaling difficulty, and layered environments.

View demo →

View guide →

Automate Monthly Dev Reports with DeepSeek via Ollama

Review a month of GitHub pull requests with a locally hosted model, generate a Word summary, and prepare the correspo

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • resources/example-skills/docx/SKILL.md7.8 KBupstream ↗
    ---
    name: docx
    description: "Use this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files). Triggers include: any mention of \"Word doc\", \"word document\", \".docx\", or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a \"report\", \"memo\", \"letter\", \"template\", or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation."
    license: Proprietary. LICENSE.txt has complete terms
    ---
    
    # DOCX creation, editing, and analysis
    
    ## Overview
    
    A .docx file is a ZIP archive containing XML files.
    
    ## Quick Reference
    
    | Task | Approach |
    |------|----------|
    | Read/analyze content | `pandoc` or unpack for raw XML |
    | Create new document | Use `docx-js` - see Creating New Documents below |
    | Edit existing document | Unpack → edit XML → repack - see Editing Existing Documents below |
    
    ### Converting .doc to .docx
    
    Legacy `.doc` files must be converted before editing:
    
    ```bash
    python scripts/office/soffice.py --headless --convert-to docx document.doc
    ```
    
    ### Reading Content
    
    ```bash
    # Text extraction with tracked changes
    pandoc --track-changes=all document.docx -o output.md
    
    # Raw XML access
    python scripts/office/unpack.py document.docx unpacked/
    ```
    
    ### Converting to Images
    
    ```bash
    python scripts/office/soffice.py --headless --convert-to pdf document.docx
    pdftoppm -jpeg -r 150 document.pdf page
    ```
    
    ### Accepting Tracked Changes
    
    To produce a clean document with all tracked changes accepted (requires LibreOffice):
    
    ```bash
    python scripts/accept_changes.py input.docx output.docx
    ```
    
    ---
    
    ## Creating New Documents
    
    Generate .docx files with JavaScript, then validate. Install: `npm install -g docx`
    
    ### Setup
    ```javascript
    const { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, ImageRun,
            Header, Footer, AlignmentType, PageOrientation, LevelFormat, ExternalHyperlink,
            TableOfContents, HeadingLevel, BorderStyle, WidthType, ShadingType,
            VerticalAlign, PageNumber, PageBreak } = require('docx');
    
    const doc = new Document({ sections: [{ children: [/* content */] }] });
    Packer.toBuffer(doc).then(buffer => fs.writeFileSync("doc.docx", buffer));
    ```
    
    ### Validation
    After creating the file, validate it. If validation fails, unpack, fix the XML, and repack.
    ```bash
    python scripts/office/validate.py doc.docx
    ```
    
    ### Page Size
    
    ```javascript
    // CRITICAL: docx-js defaults to A4, not US Letter
    // Always set page size explicitly for consistent results
    sections: [{
      properties: {
        page: {
          size: {
            width: 12240,   // 8.5 inches in DXA
            height: 15840   // 11 inches in DXA
          },
          margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 } // 1 inch margins
        }
      },
      children: [/* content */]
    }]
    ```
    
    **Common page sizes (DXA units, 1440 DXA = 1 inch):**
    
    | Paper | Width | Height | Content Width (1" margins) |
    |-------|-------|--------|---------------------------|
    | US Letter | 12,240 | 15,840 | 9,360 |
    | A4 (default) | 11,906 | 16,838 | 9,026 |
    
    **Landscape orientation:** docx-js swaps width/height internally, so pass portrait dimensions and let it handle the swap:
    ```javascript
    size: {
      width: 12240,   // Pass SHORT edge as width
      height: 15840,  // Pass LONG edge as height
      orientation: PageOrientation.LANDSCAPE  // docx-js swaps them in the XML
    },
    // Content width = 15840 - left margin - right margin (uses the long edge)
    ```
    
    ### Styles (Override Built-in Headings)
    
    Use Arial as the default font (universally supported). Keep titles black for readability.
    
    ```javascript
    const doc = new Document({
      styles: {
        default: { document: { run: { font: "Arial", size: 24 } } }, // 12pt default
        paragraphStyles: [
          // IMPORTANT: Use exact IDs to override built-in styles
          { id: "Heading1", name: "Heading 1", basedOn: "Normal", next: "Normal", quickFormat: true,
            run: { size: 32, bold: true, font: "Arial" },
            paragraph: { spacing: { before: 240, after: 240 }, outlineLevel: 0 } }, // outlineLevel required for TOC
          { id: "Heading2", name: "Heading 2", basedOn: "Normal", next: "Normal", quickFormat: true,
            run: { size: 28, bold: true, font: "Arial" },
            paragraph: { spacing: { before: 180, after: 180 }, outlineLevel: 1 } },
        ]
      },
      sections: [{
        children: [
          new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new TextRun("Title")] }),
        ]
      }]
    });
    ```
    
    ### Lists (NEVER use unicode bullets)
    
    ```javascript
    // ❌ WRONG - never manually insert bullet characters
    new Paragraph({ children: [new TextRun("• Item")] })  // BAD
    new Paragraph({ children: [new TextRun("• Item")] })  // BAD
    
    // ✅ CORRECT - use numbering config with LevelFormat.BULLET
    const doc = new Document({
      numbering: {
        config: [
          { reference: "bullets",
            levels: [{ level: 0, format: LevelFormat.BULLET, text: "•", alignment: AlignmentType.LEFT,
              style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
          { reference: "numbers",
            levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT,
              style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
        ]
      },
      sections: [{
        children: [
          new Paragraph({ numbering: { reference: "bullets", level: 0 },
            children: [new TextRun("Bullet item")] }),
          new Paragraph({ numbering: { reference: "numbers", level: 0 },
            children: [new TextRun("Numbered item")] }),
        ]
      }]
    });
    
    // ⚠️ Each reference creates INDEPENDENT numbering
    // Same reference = continues (1,2,3 then 4,5,6)
    // Different reference = restarts (1,2,3 then 1,2,3)
    ```
    
    ### Tables
    
    **CRITICAL: Tables need dual widths** - set both `columnWidths` on the table AND `width` on each cell. Without both, tables render incorrectly on some platforms.
    
    ```javascript
    // CRITICAL: Always set table width for consistent rendering
    // CRITICAL: Use ShadingType.CLEAR (not SOLID) to prevent black backgrounds
    const border = { style: BorderStyle.SINGLE, size: 1, color: "CCCCCC" };
    const borders = { top: border, bottom: border, left: border, right: border };
    
    new Table({
      width: { size: 9360, type: WidthType.DXA }, // Always use DXA (percentages break in Google Docs)
      columnWidths: [4680, 4680], // Must sum to table width (DXA: 1440 = 1 inch)
      rows: [
        new TableRow({
          children: [
            new TableCell({
              borders,
              width: { size: 4680, type: WidthType.DXA }, // Also set on each cell
              shading: { fill: "D5E8F0", type: ShadingType.CLEAR }, // CLEAR not SOLID
              margins: { top: 80, bottom: 80, left: 120, right: 120 }, // Cell padding (internal, not added to width)
              children: [new Paragraph({ children: [new TextRun("Cell")] })]
            })
          ]
        })
      ]
    })
    ```
    
    **Table width calculation:**
    
    Always use `WidthType.DXA` — `WidthType.PERCENTAGE` breaks in Google Docs.
    
    ```javascript
    // Table width = sum of columnWidths = content width
    // US Letter with 1" margins: 12240 - 2880 = 9360 DXA
    width: { size: 9360, type: WidthType.DXA },
    columnWidths: [7000, 2360]  // Must sum to table width
    ```
    
    **Width rules:**
    - **Always use `WidthType.DXA`** — never `WidthType.PERCENTAGE` (incompatible with Google Docs)
    - Table width must equal the sum of `columnWidths`
    - Cell `width` must match corresponding `columnWidth`
    - Cell `margins` are internal padding - they reduce content area, not add to cell width
    - For full-width tables: use content width (page width minus left and right margins)
    
    ### Images
    
    ```javascript
    // CRITICAL: type parameter is REQUIRED
    new Pa
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/eigent-ai-eigent-resources-example-skills-docx.md

// REPO STATS

15.8k stars
173 open issues
Last commit: 2d ago