Word Document Creator

What this skill does

# Word Document Creator

The Word Document Creator skill provides comprehensive capabilities for generating Microsoft Word (.docx) documents programmatically. It handles formatting, styles, tables, images, headers, footers, and complex layouts using the `docx` library for Node.js. This skill is essential for automated document generation, report creation, and template-based workflows.

Create everything from simple letters to complex reports with tables, charts, images, and custom styling. The skill supports both creation from scratch and template-based generation with variable replacement.

## Core Workflows

### Workflow 1: Create Formatted Document from Scratch
**Purpose:** Build a Word document with headings, paragraphs, lists, and formatting

**Steps:**
1. Import `docx` library and create Document instance
2. Define styles for headings, body text, lists
3. Add sections with headers and footers
4. Create paragraphs with formatting (bold, italic, color, alignment)
5. Add numbered and bulleted lists
6. Insert tables with formatting
7. Export to .docx file

**Implementation:**
```javascript
const { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType } = require('docx');
const fs = require('fs');

async function createDocument(outputPath) {
  const doc = new Document({
    sections: [{
      properties: {},
      headers: {
        default: new Header({
          children: [new Paragraph({ text: "Company Name", alignment: AlignmentType.RIGHT })]
        })
      },
      children: [
        new Paragraph({
          text: "Business Proposal",
          heading: HeadingLevel.HEADING_1,
          alignment: AlignmentType.CENTER
        }),
        new Paragraph({
          children: [
            new TextRun({ text: "Prepared for: ", bold: true }),
            new TextRun("Client Name")
          ]
        }),
        new Paragraph({
          text: "Executive Summary",
          heading: HeadingLevel.HEADING_2
        }),
        new Paragraph({
          text: "This proposal outlines the scope, timeline, and budget for the project...",
          alignment: AlignmentType.JUSTIFIED
        })
      ]
    }]
  });

  const buffer = await Packer.toBuffer(doc);
  fs.writeFileSync(outputPath, buffer);
}
```

### Workflow 2: Generate Document from Template
**Purpose:** Use a template Word file and replace placeholders with actual data

**Steps:**
1. Load template .docx file using `pizzip` and `docxtemplater`
2. Define data object with replacement values
3. Set data to template
4. Render template with substitutions
5. Handle loops for repeated sections (tables, lists)
6. Handle images and conditional sections
7. Export final document

**Implementation:**
```javascript
const Docxtemplater = require('docxtemplater');
const PizZip = require('pizzip');
const fs = require('fs');

function generateFromTemplate(templatePath, data, outputPath) {
  const content = fs.readFileSync(templatePath, 'binary');
  const zip = new PizZip(content);

  const doc = new Docxtemplater(zip, {
    paragraphLoop: true,
    linebreaks: true
  });

  // Data object with placeholder values
  doc.setData({
    clientName: data.clientName,
    projectName: data.projectName,
    date: new Date().toLocaleDateString(),
    items: data.items, // Array for looping
    total: data.total
  });

  doc.render();

  const buf = doc.getZip().generate({
    type: 'nodebuffer',
    compression: 'DEFLATE'
  });

  fs.writeFileSync(outputPath, buf);
}

// Template placeholders: {clientName}, {projectName}, etc.
// Loop syntax: {#items}{name} - {price}{/items}
```

### Workflow 3: Create Document with Tables and Images
**Purpose:** Build complex documents containing data tables and embedded images

**Steps:**
1. Create Document instance
2. Define table with rows and columns
3. Set cell formatting (borders, shading, alignment)
4. Add table headers with bold styling
5. Populate data rows
6. Insert images with sizing and positioning
7. Add captions to images
8. Export document

**Implementation:**
```javascript
const { Document, Packer, Paragraph, Table, TableRow, TableCell, Media } = require('docx');
const fs = require('fs');

async function createTableDocument(data, imagePath, outputPath) {
  const image = Media.addImage(doc, fs.readFileSync(imagePath), 300, 200);

  const doc = new Document({
    sections: [{
      children: [
        new Paragraph({ text: "Sales Report Q4 2025", heading: HeadingLevel.HEADING_1 }),
        new Table({
          rows: [
            // Header row
            new TableRow({
              children: [
                new TableCell({ children: [new Paragraph({ text: "Month", bold: true })] }),
                new TableCell({ children: [new Paragraph({ text: "Revenue", bold: true })] }),
                new TableCell({ children: [new Paragraph({ text: "Growth", bold: true })] })
              ]
            }),
            // Data rows
            ...data.map(row => new TableRow({
              children: [
                new TableCell({ children: [new Paragraph(row.month)] }),
                new TableCell({ children: [new Paragraph(row.revenue)] }),
                new TableCell({ children: [new Paragraph(row.growth)] })
              ]
            }))
          ]
        }),
        new Paragraph({ text: "" }), // Spacing
        new Paragraph({ text: "Revenue Trend Chart", heading: HeadingLevel.HEADING_2 }),
        new Paragraph({ children: [image] }),
        new Paragraph({ text: "Figure 1: Quarterly Revenue Trend", italics: true })
      ]
    }]
  });

  const buffer = await Packer.toBuffer(doc);
  fs.writeFileSync(outputPath, buffer);
}
```

### Workflow 4: Batch Generate Documents
**Purpose:** Create multiple personalized documents from a data source

**Steps:**
1. Load data source (JSON, CSV, database)
2. Load document template
3. For each record:
   - Create new document instance
   - Populate with record data
   - Apply formatting
   - Save with unique filename
4. Track success/failure for each document
5. Generate summary report

### Workflow 5: Add Advanced Formatting
**Purpose:** Apply styles, fonts, colors, spacing, and page layout

**Steps:**
1. Define custom styles in document
2. Create style hierarchy (heading levels, body, captions)
3. Set font families, sizes, colors
4. Configure paragraph spacing and indentation
5. Set page margins and orientation
6. Add page numbers and section breaks
7. Apply themes and color schemes

**Implementation:**
```javascript
const doc = new Document({
  styles: {
    paragraphStyles: [
      {
        id: "CustomHeading",
        name: "Custom Heading",
        basedOn: "Heading1",
        next: "Normal",
        run: {
          size: 32,
          bold: true,
          color: "2E74B5",
          font: "Calibri"
        },
        paragraph: {
          spacing: { before: 240, after: 120 }
        }
      }
    ]
  },
  sections: [{
    properties: {
      page: {
        margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 } // 1440 = 1 inch
      }
    },
    children: [
      new Paragraph({ text: "Styled Heading", style: "CustomHeading" })
    ]
  }]
});
```

## Quick Reference

| Action | Command/Trigger |
|--------|-----------------|
| Create new document | "create word document [name]" |
| From template | "generate docx from template [file]" |
| Add table | "add table with [rows] rows to [doc]" |
| Insert image | "insert [image] into word doc" |
| Batch generate | "create word docs for each [data]" |
| Apply style | "format word doc with [style]" |
| Add header/footer | "add header [text] to document" |
| Create TOC | "generate table of contents" |

## Best Practices

- **Styles Over Direct Formatting:** Define and use styles for consistency and easy updates
- **Templates:** Use templates for repeated document types (contracts, reports, letters)
- **Page Layout:** Set margins, orientation, and page size early in document creation
- **Tables:** Use table styles for professional appearance and easy