anchi-toolkit 1.0.0 → 1.2.1

package/dist/.cursor/skills/docs-seeker/workflows/topic-search.md

@@ -0,0 +1,77 @@
+# Topic-Specific Documentation Search
+
+**Use when:** User asks about specific feature/component/concept
+
+**Speed:** ⚡ Fastest (10-15s)
+**Token usage:** 🟢 Minimal
+**Accuracy:** 🎯 Highly targeted
+
+## Trigger Patterns
+
+- "How do I use [FEATURE] in [LIBRARY]?"
+- "[LIBRARY] [COMPONENT] documentation"
+- "Implement [FEATURE] with [LIBRARY]"
+- "[LIBRARY] [CONCEPT] guide"
+
+## Workflow (Script-First)
+
+```bash
+# STEP 1: Execute detect-topic.js script
+node scripts/detect-topic.js "<user query>"
+# Returns: {"topic": "X", "library": "Y", "isTopicSpecific": true}
+
+# STEP 2: Execute fetch-docs.js script (handles URL construction automatically)
+node scripts/fetch-docs.js "<user query>"
+# Script constructs: context7.com/{library}/llms.txt?topic={topic}
+# Script handles fallback if topic URL fails
+# Returns: llms.txt content with 1-5 URLs
+
+# STEP 3: Process results based on URL count
+# - 1-3 URLs: Read directly with WebFetch tool
+# - 4-5 URLs: Deploy 2-3 Explorer agents in parallel
+
+# STEP 4: Present findings
+# Focus on specific feature: installation, usage, examples
+```
+
+## Examples
+
+**shadcn date picker:**
+```bash
+# Execute script (automatic URL construction)
+node scripts/detect-topic.js "How do I use date picker in shadcn?"
+# {"topic": "date", "library": "shadcn/ui", "isTopicSpecific": true}
+
+node scripts/fetch-docs.js "How do I use date picker in shadcn?"
+# Script fetches: context7.com/shadcn-ui/ui/llms.txt?topic=date
+# Returns: 2-3 date-specific URLs
+
+# Read URLs directly with WebFetch
+# Present date picker documentation
+```
+
+**Next.js caching:**
+```bash
+# Execute scripts (no manual URL needed)
+node scripts/detect-topic.js "Next.js caching strategies"
+# {"topic": "cache", "library": "next.js", "isTopicSpecific": true}
+
+node scripts/fetch-docs.js "Next.js caching strategies"
+# Script fetches: context7.com/vercel/next.js/llms.txt?topic=cache
+# Returns: 3-4 URLs
+
+# Process URLs via 2 Explorer agents
+# Present caching strategies
+```
+
+## Benefits
+
+✅ 10x faster than full docs
+✅ No filtering needed
+✅ Minimal context load
+✅ Best user experience
+
+## Fallback
+
+If topic URL returns 404:
+→ Fallback to [General Library Search](./library-search.md)

package/dist/.cursor/skills/document-skills/docx/LICENSE.txt

@@ -0,0 +1,30 @@
+© 2025 Anthropic, PBC. All rights reserved.
+
+LICENSE: Use of these materials (including all code, prompts, assets, files,
+and other components of this Skill) is governed by your agreement with
+Anthropic regarding use of Anthropic's services. If no separate agreement
+exists, use is governed by Anthropic's Consumer Terms of Service or
+Commercial Terms of Service, as applicable:
+https://www.anthropic.com/legal/consumer-terms
+https://www.anthropic.com/legal/commercial-terms
+Your applicable agreement is referred to as the "Agreement." "Services" are
+as defined in the Agreement.
+
+ADDITIONAL RESTRICTIONS: Notwithstanding anything in the Agreement to the
+contrary, users may not:
+
+- Extract these materials from the Services or retain copies of these
+  materials outside the Services
+- Reproduce or copy these materials, except for temporary copies created
+  automatically during authorized use of the Services
+- Create derivative works based on these materials
+- Distribute, sublicense, or transfer these materials to any third party
+- Make, offer to sell, sell, or import any inventions embodied in these
+  materials
+- Reverse engineer, decompile, or disassemble these materials
+
+The receipt, viewing, or possession of these materials does not convey or
+imply any license or right beyond those expressly granted above.
+
+Anthropic retains all right, title, and interest in these materials,
+including all copyrights, patents, and other intellectual property rights.

package/dist/.cursor/skills/document-skills/docx/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: docx
+description: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# DOCX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
+
+## Workflow Decision Tree
+
+### Reading/Analyzing Content
+Use "Text extraction" or "Raw XML access" sections below
+
+### Creating New Document
+Use "Creating a new Word document" workflow
+
+### Editing Existing Document
+- **Your own document + simple changes**
+  Use "Basic OOXML editing" workflow
+
+- **Someone else's document**
+  Use **"Redlining workflow"** (recommended default)
+
+- **Legal, academic, business, or government docs**
+  Use **"Redlining workflow"** (required)
+
+## Reading and analyzing content
+
+### Text extraction
+If you just need to read the text contents of a document, you should convert the document to markdown using pandoc. Pandoc provides excellent support for preserving document structure and can show tracked changes:
+
+```bash
+# Convert document to markdown with tracked changes
+pandoc --track-changes=all path-to-file.docx -o output.md
+# Options: --track-changes=accept/reject/all
+```
+
+### Raw XML access
+You need raw XML access for: comments, complex formatting, document structure, embedded media, and metadata. For any of these features, you'll need to unpack a document and read its raw XML contents.
+
+#### Unpacking a file
+`python ooxml/scripts/unpack.py <office_file> <output_directory>`
+
+#### Key file structures
+* `word/document.xml` - Main document contents
+* `word/comments.xml` - Comments referenced in document.xml
+* `word/media/` - Embedded images and media files
+* Tracked changes use `<w:ins>` (insertions) and `<w:del>` (deletions) tags
+
+## Creating a new Word document
+
+When creating a new Word document from scratch, use **docx-js**, which allows you to create Word documents using JavaScript/TypeScript.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.
+2. Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)
+3. Export as .docx using Packer.toBuffer()
+
+## Editing an existing Word document
+
+When editing an existing Word document, use the **Document library** (a Python library for OOXML manipulation). The library automatically handles infrastructure setup and provides methods for document manipulation. For complex scenarios, you can access the underlying DOM directly through the library.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.
+2. Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`
+3. Create and run a Python script using the Document library (see "Document Library" section in ooxml.md)
+4. Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`
+
+The Document library provides both high-level methods for common operations and direct DOM access for complex scenarios.
+
+## Redlining workflow for document review
+
+This workflow allows you to plan comprehensive tracked changes using markdown before implementing them in OOXML. **CRITICAL**: For complete tracked changes, you must implement ALL changes systematically.
+
+**Batching Strategy**: Group related changes into batches of 3-10 changes. This makes debugging manageable while maintaining efficiency. Test each batch before moving to the next.
+
+**Principle: Minimal, Precise Edits**
+When implementing tracked changes, only mark text that actually changes. Repeating unchanged text makes edits harder to review and appears unprofessional. Break replacements into: [unchanged text] + [deletion] + [insertion] + [unchanged text]. Preserve the original run's RSID for unchanged text by extracting the `<w:r>` element from the original and reusing it.
+
+Example - Changing "30 days" to "60 days" in a sentence:
+```python
+# BAD - Replaces entire sentence
+'<w:del><w:r><w:delText>The term is 30 days.</w:delText></w:r></w:del><w:ins><w:r><w:t>The term is 60 days.</w:t></w:r></w:ins>'
+
+# GOOD - Only marks what changed, preserves original <w:r> for unchanged text
+'<w:r w:rsidR="00AB12CD"><w:t>The term is </w:t></w:r><w:del><w:r><w:delText>30</w:delText></w:r></w:del><w:ins><w:r><w:t>60</w:t></w:r></w:ins><w:r w:rsidR="00AB12CD"><w:t> days.</w:t></w:r>'
+```
+
+### Tracked changes workflow
+
+1. **Get markdown representation**: Convert document to markdown with tracked changes preserved:
+   ```bash
+   pandoc --track-changes=all path-to-file.docx -o current.md
+   ```
+
+2. **Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:
+
+   **Location methods** (for finding changes in XML):
+   - Section/heading numbers (e.g., "Section 3.2", "Article IV")
+   - Paragraph identifiers if numbered
+   - Grep patterns with unique surrounding text
+   - Document structure (e.g., "first paragraph", "signature block")
+   - **DO NOT use markdown line numbers** - they don't map to XML structure
+
+   **Batch organization** (group 3-10 related changes per batch):
+   - By section: "Batch 1: Section 2 amendments", "Batch 2: Section 5 updates"
+   - By type: "Batch 1: Date corrections", "Batch 2: Party name changes"
+   - By complexity: Start with simple text replacements, then tackle complex structural changes
+   - Sequential: "Batch 1: Pages 1-3", "Batch 2: Pages 4-6"
+
+3. **Read documentation and unpack**:
+   - **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Pay special attention to the "Document Library" and "Tracked Change Patterns" sections.
+   - **Unpack the document**: `python ooxml/scripts/unpack.py <file.docx> <dir>`
+   - **Note the suggested RSID**: The unpack script will suggest an RSID to use for your tracked changes. Copy this RSID for use in step 4b.
+
+4. **Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:
+   - Makes debugging easier (smaller batch = easier to isolate errors)
+   - Allows incremental progress
+   - Maintains efficiency (batch size of 3-10 changes works well)
+
+   **Suggested batch groupings:**
+   - By document section (e.g., "Section 3 changes", "Definitions", "Termination clause")
+   - By change type (e.g., "Date changes", "Party name updates", "Legal term replacements")
+   - By proximity (e.g., "Changes on pages 1-3", "Changes in first half of document")
+
+   For each batch of related changes:
+
+   **a. Map text to XML**: Grep for text in `word/document.xml` to verify how text is split across `<w:r>` elements.
+
+   **b. Create and run script**: Use `get_node` to find nodes, implement changes, then `doc.save()`. See **"Document Library"** section in ooxml.md for patterns.
+
+   **Note**: Always grep `word/document.xml` immediately before writing a script to get current line numbers and verify text content. Line numbers change after each script run.
+
+5. **Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:
+   ```bash
+   python ooxml/scripts/pack.py unpacked reviewed-document.docx
+   ```
+
+6. **Final verification**: Do a comprehensive check of the complete document:
+   - Convert final document to markdown:
+     ```bash
+     pandoc --track-changes=all reviewed-document.docx -o verification.md
+     ```
+   - Verify ALL changes were applied correctly:
+     ```bash
+     grep "original phrase" verification.md  # Should NOT find it
+     grep "replacement phrase" verification.md  # Should find it
+     ```
+   - Check that no unintended changes were introduced
+
+
+## Converting Documents to Images
+
+To visually analyze Word documents, convert them to images using a two-step process:
+
+1. **Convert DOCX to PDF**:
+   ```bash
+   soffice --headless --convert-to pdf document.docx
+   ```
+
+2. **Convert PDF pages to JPEG images**:
+   ```bash
+   pdftoppm -jpeg -r 150 document.pdf page
+   ```
+   This creates files like `page-1.jpg`, `page-2.jpg`, etc.
+
+Options:
+- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
+- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
+- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
+- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
+- `page`: Prefix for output files
+
+Example for specific range:
+```bash
+pdftoppm -jpeg -r 150 -f 2 -l 5 document.pdf page  # Converts only pages 2-5
+```
+
+## Code Style Guidelines
+**IMPORTANT**: When generating code for DOCX operations:
+- Write concise code
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+## Dependencies
+
+Required dependencies (install if not available):
+
+- **pandoc**: `sudo apt-get install pandoc` (for text extraction)
+- **docx**: `npm install -g docx` (for creating new documents)
+- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
+- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
+- **defusedxml**: `pip install defusedxml` (for secure XML parsing)

package/dist/.cursor/skills/document-skills/docx/docx-js.md

@@ -0,0 +1,350 @@
+# DOCX Library Tutorial
+
+Generate .docx files with JavaScript/TypeScript.
+
+**Important: Read this entire document before starting.** Critical formatting rules and common pitfalls are covered throughout - skipping sections may result in corrupted files or rendering issues.
+
+## Setup
+Assumes docx is already installed globally
+If not installed: `npm install -g docx`
+
+```javascript
+const { Document, Packer, Paragraph, TextRun, Table, TableRow, TableCell, ImageRun, Media, 
+        Header, Footer, AlignmentType, PageOrientation, LevelFormat, ExternalHyperlink, 
+        InternalHyperlink, TableOfContents, HeadingLevel, BorderStyle, WidthType, TabStopType, 
+        TabStopPosition, UnderlineType, ShadingType, VerticalAlign, SymbolRun, PageNumber,
+        FootnoteReferenceRun, Footnote, PageBreak } = require('docx');
+
+// Create & Save
+const doc = new Document({ sections: [{ children: [/* content */] }] });
+Packer.toBuffer(doc).then(buffer => fs.writeFileSync("doc.docx", buffer)); // Node.js
+Packer.toBlob(doc).then(blob => { /* download logic */ }); // Browser
+```
+
+## Text & Formatting
+```javascript
+// IMPORTANT: Never use \n for line breaks - always use separate Paragraph elements
+// ❌ WRONG: new TextRun("Line 1\nLine 2")
+// ✅ CORRECT: new Paragraph({ children: [new TextRun("Line 1")] }), new Paragraph({ children: [new TextRun("Line 2")] })
+
+// Basic text with all formatting options
+new Paragraph({
+  alignment: AlignmentType.CENTER,
+  spacing: { before: 200, after: 200 },
+  indent: { left: 720, right: 720 },
+  children: [
+    new TextRun({ text: "Bold", bold: true }),
+    new TextRun({ text: "Italic", italics: true }),
+    new TextRun({ text: "Underlined", underline: { type: UnderlineType.DOUBLE, color: "FF0000" } }),
+    new TextRun({ text: "Colored", color: "FF0000", size: 28, font: "Arial" }), // Arial default
+    new TextRun({ text: "Highlighted", highlight: "yellow" }),
+    new TextRun({ text: "Strikethrough", strike: true }),
+    new TextRun({ text: "x2", superScript: true }),
+    new TextRun({ text: "H2O", subScript: true }),
+    new TextRun({ text: "SMALL CAPS", smallCaps: true }),
+    new SymbolRun({ char: "2022", font: "Symbol" }), // Bullet •
+    new SymbolRun({ char: "00A9", font: "Arial" })   // Copyright © - Arial for symbols
+  ]
+})
+```
+
+## Styles & Professional Formatting
+
+```javascript
+const doc = new Document({
+  styles: {
+    default: { document: { run: { font: "Arial", size: 24 } } }, // 12pt default
+    paragraphStyles: [
+      // Document title style - override built-in Title style
+      { id: "Title", name: "Title", basedOn: "Normal",
+        run: { size: 56, bold: true, color: "000000", font: "Arial" },
+        paragraph: { spacing: { before: 240, after: 120 }, alignment: AlignmentType.CENTER } },
+      // IMPORTANT: Override built-in heading styles by using their exact IDs
+      { id: "Heading1", name: "Heading 1", basedOn: "Normal", next: "Normal", quickFormat: true,
+        run: { size: 32, bold: true, color: "000000", font: "Arial" }, // 16pt
+        paragraph: { spacing: { before: 240, after: 240 }, outlineLevel: 0 } }, // Required for TOC
+      { id: "Heading2", name: "Heading 2", basedOn: "Normal", next: "Normal", quickFormat: true,
+        run: { size: 28, bold: true, color: "000000", font: "Arial" }, // 14pt
+        paragraph: { spacing: { before: 180, after: 180 }, outlineLevel: 1 } },
+      // Custom styles use your own IDs
+      { id: "myStyle", name: "My Style", basedOn: "Normal",
+        run: { size: 28, bold: true, color: "000000" },
+        paragraph: { spacing: { after: 120 }, alignment: AlignmentType.CENTER } }
+    ],
+    characterStyles: [{ id: "myCharStyle", name: "My Char Style",
+      run: { color: "FF0000", bold: true, underline: { type: UnderlineType.SINGLE } } }]
+  },
+  sections: [{
+    properties: { page: { margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 } } },
+    children: [
+      new Paragraph({ heading: HeadingLevel.TITLE, children: [new TextRun("Document Title")] }), // Uses overridden Title style
+      new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new TextRun("Heading 1")] }), // Uses overridden Heading1 style
+      new Paragraph({ style: "myStyle", children: [new TextRun("Custom paragraph style")] }),
+      new Paragraph({ children: [
+        new TextRun("Normal with "),
+        new TextRun({ text: "custom char style", style: "myCharStyle" })
+      ]})
+    ]
+  }]
+});
+```
+
+**Professional Font Combinations:**
+- **Arial (Headers) + Arial (Body)** - Most universally supported, clean and professional
+- **Times New Roman (Headers) + Arial (Body)** - Classic serif headers with modern sans-serif body
+- **Georgia (Headers) + Verdana (Body)** - Optimized for screen reading, elegant contrast
+
+**Key Styling Principles:**
+- **Override built-in styles**: Use exact IDs like "Heading1", "Heading2", "Heading3" to override Word's built-in heading styles
+- **HeadingLevel constants**: `HeadingLevel.HEADING_1` uses "Heading1" style, `HeadingLevel.HEADING_2` uses "Heading2" style, etc.
+- **Include outlineLevel**: Set `outlineLevel: 0` for H1, `outlineLevel: 1` for H2, etc. to ensure TOC works correctly
+- **Use custom styles** instead of inline formatting for consistency
+- **Set a default font** using `styles.default.document.run.font` - Arial is universally supported
+- **Establish visual hierarchy** with different font sizes (titles > headers > body)
+- **Add proper spacing** with `before` and `after` paragraph spacing
+- **Use colors sparingly**: Default to black (000000) and shades of gray for titles and headings (heading 1, heading 2, etc.)
+- **Set consistent margins** (1440 = 1 inch is standard)
+
+
+## Lists (ALWAYS USE PROPER LISTS - NEVER USE UNICODE BULLETS)
+```javascript
+// Bullets - ALWAYS use the numbering config, NOT unicode symbols
+// CRITICAL: Use LevelFormat.BULLET constant, NOT the string "bullet"
+const doc = new Document({
+  numbering: {
+    config: [
+      { reference: "bullet-list",
+        levels: [{ level: 0, format: LevelFormat.BULLET, text: "•", alignment: AlignmentType.LEFT,
+          style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
+      { reference: "first-numbered-list",
+        levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT,
+          style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] },
+      { reference: "second-numbered-list", // Different reference = restarts at 1
+        levels: [{ level: 0, format: LevelFormat.DECIMAL, text: "%1.", alignment: AlignmentType.LEFT,
+          style: { paragraph: { indent: { left: 720, hanging: 360 } } } }] }
+    ]
+  },
+  sections: [{
+    children: [
+      // Bullet list items
+      new Paragraph({ numbering: { reference: "bullet-list", level: 0 },
+        children: [new TextRun("First bullet point")] }),
+      new Paragraph({ numbering: { reference: "bullet-list", level: 0 },
+        children: [new TextRun("Second bullet point")] }),
+      // Numbered list items
+      new Paragraph({ numbering: { reference: "first-numbered-list", level: 0 },
+        children: [new TextRun("First numbered item")] }),
+      new Paragraph({ numbering: { reference: "first-numbered-list", level: 0 },
+        children: [new TextRun("Second numbered item")] }),
+      // ⚠️ CRITICAL: Different reference = INDEPENDENT list that restarts at 1
+      // Same reference = CONTINUES previous numbering
+      new Paragraph({ numbering: { reference: "second-numbered-list", level: 0 },
+        children: [new TextRun("Starts at 1 again (because different reference)")] })
+    ]
+  }]
+});
+
+// ⚠️ CRITICAL NUMBERING RULE: Each reference creates an INDEPENDENT numbered list
+// - Same reference = continues numbering (1, 2, 3... then 4, 5, 6...)
+// - Different reference = restarts at 1 (1, 2, 3... then 1, 2, 3...)
+// Use unique reference names for each separate numbered section!
+
+// ⚠️ CRITICAL: NEVER use unicode bullets - they create fake lists that don't work properly
+// new TextRun("• Item")           // WRONG
+// new SymbolRun({ char: "2022" }) // WRONG
+// ✅ ALWAYS use numbering config with LevelFormat.BULLET for real Word lists
+```
+
+## Tables
+```javascript
+// Complete table with margins, borders, headers, and bullet points
+const tableBorder = { style: BorderStyle.SINGLE, size: 1, color: "CCCCCC" };
+const cellBorders = { top: tableBorder, bottom: tableBorder, left: tableBorder, right: tableBorder };
+
+new Table({
+  columnWidths: [4680, 4680], // ⚠️ CRITICAL: Set column widths at table level - values in DXA (twentieths of a point)
+  margins: { top: 100, bottom: 100, left: 180, right: 180 }, // Set once for all cells
+  rows: [
+    new TableRow({
+      tableHeader: true,
+      children: [
+        new TableCell({
+          borders: cellBorders,
+          width: { size: 4680, type: WidthType.DXA }, // ALSO set width on each cell
+          // ⚠️ CRITICAL: Always use ShadingType.CLEAR to prevent black backgrounds in Word.
+          shading: { fill: "D5E8F0", type: ShadingType.CLEAR }, 
+          verticalAlign: VerticalAlign.CENTER,
+          children: [new Paragraph({ 
+            alignment: AlignmentType.CENTER,
+            children: [new TextRun({ text: "Header", bold: true, size: 22 })]
+          })]
+        }),
+        new TableCell({
+          borders: cellBorders,
+          width: { size: 4680, type: WidthType.DXA }, // ALSO set width on each cell
+          shading: { fill: "D5E8F0", type: ShadingType.CLEAR },
+          children: [new Paragraph({ 
+            alignment: AlignmentType.CENTER,
+            children: [new TextRun({ text: "Bullet Points", bold: true, size: 22 })]
+          })]
+        })
+      ]
+    }),
+    new TableRow({
+      children: [
+        new TableCell({
+          borders: cellBorders,
+          width: { size: 4680, type: WidthType.DXA }, // ALSO set width on each cell
+          children: [new Paragraph({ children: [new TextRun("Regular data")] })]
+        }),
+        new TableCell({
+          borders: cellBorders,
+          width: { size: 4680, type: WidthType.DXA }, // ALSO set width on each cell
+          children: [
+            new Paragraph({ 
+              numbering: { reference: "bullet-list", level: 0 },
+              children: [new TextRun("First bullet point")] 
+            }),
+            new Paragraph({ 
+              numbering: { reference: "bullet-list", level: 0 },
+              children: [new TextRun("Second bullet point")] 
+            })
+          ]
+        })
+      ]
+    })
+  ]
+})
+```
+
+**IMPORTANT: Table Width & Borders**
+- Use BOTH `columnWidths: [width1, width2, ...]` array AND `width: { size: X, type: WidthType.DXA }` on each cell
+- Values in DXA (twentieths of a point): 1440 = 1 inch, Letter usable width = 9360 DXA (with 1" margins)
+- Apply borders to individual `TableCell` elements, NOT the `Table` itself
+
+**Precomputed Column Widths (Letter size with 1" margins = 9360 DXA total):**
+- **2 columns:** `columnWidths: [4680, 4680]` (equal width)
+- **3 columns:** `columnWidths: [3120, 3120, 3120]` (equal width)
+
+## Links & Navigation
+```javascript
+// TOC (requires headings) - CRITICAL: Use HeadingLevel only, NOT custom styles
+// ❌ WRONG: new Paragraph({ heading: HeadingLevel.HEADING_1, style: "customHeader", children: [new TextRun("Title")] })
+// ✅ CORRECT: new Paragraph({ heading: HeadingLevel.HEADING_1, children: [new TextRun("Title")] })
+new TableOfContents("Table of Contents", { hyperlink: true, headingStyleRange: "1-3" }),
+
+// External link
+new Paragraph({
+  children: [new ExternalHyperlink({
+    children: [new TextRun({ text: "Google", style: "Hyperlink" })],
+    link: "https://www.google.com"
+  })]
+}),
+
+// Internal link & bookmark
+new Paragraph({
+  children: [new InternalHyperlink({
+    children: [new TextRun({ text: "Go to Section", style: "Hyperlink" })],
+    anchor: "section1"
+  })]
+}),
+new Paragraph({
+  children: [new TextRun("Section Content")],
+  bookmark: { id: "section1", name: "section1" }
+}),
+```
+
+## Images & Media
+```javascript
+// Basic image with sizing & positioning
+// CRITICAL: Always specify 'type' parameter - it's REQUIRED for ImageRun
+new Paragraph({
+  alignment: AlignmentType.CENTER,
+  children: [new ImageRun({
+    type: "png", // NEW REQUIREMENT: Must specify image type (png, jpg, jpeg, gif, bmp, svg)
+    data: fs.readFileSync("image.png"),
+    transformation: { width: 200, height: 150, rotation: 0 }, // rotation in degrees
+    altText: { title: "Logo", description: "Company logo", name: "Name" } // IMPORTANT: All three fields are required
+  })]
+})
+```
+
+## Page Breaks
+```javascript
+// Manual page break
+new Paragraph({ children: [new PageBreak()] }),
+
+// Page break before paragraph
+new Paragraph({
+  pageBreakBefore: true,
+  children: [new TextRun("This starts on a new page")]
+})
+
+// ⚠️ CRITICAL: NEVER use PageBreak standalone - it will create invalid XML that Word cannot open
+// ❌ WRONG: new PageBreak() 
+// ✅ CORRECT: new Paragraph({ children: [new PageBreak()] })
+```
+
+## Headers/Footers & Page Setup
+```javascript
+const doc = new Document({
+  sections: [{
+    properties: {
+      page: {
+        margin: { top: 1440, right: 1440, bottom: 1440, left: 1440 }, // 1440 = 1 inch
+        size: { orientation: PageOrientation.LANDSCAPE },
+        pageNumbers: { start: 1, formatType: "decimal" } // "upperRoman", "lowerRoman", "upperLetter", "lowerLetter"
+      }
+    },
+    headers: {
+      default: new Header({ children: [new Paragraph({ 
+        alignment: AlignmentType.RIGHT,
+        children: [new TextRun("Header Text")]
+      })] })
+    },
+    footers: {
+      default: new Footer({ children: [new Paragraph({ 
+        alignment: AlignmentType.CENTER,
+        children: [new TextRun("Page "), new TextRun({ children: [PageNumber.CURRENT] }), new TextRun(" of "), new TextRun({ children: [PageNumber.TOTAL_PAGES] })]
+      })] })
+    },
+    children: [/* content */]
+  }]
+});
+```
+
+## Tabs
+```javascript
+new Paragraph({
+  tabStops: [
+    { type: TabStopType.LEFT, position: TabStopPosition.MAX / 4 },
+    { type: TabStopType.CENTER, position: TabStopPosition.MAX / 2 },
+    { type: TabStopType.RIGHT, position: TabStopPosition.MAX * 3 / 4 }
+  ],
+  children: [new TextRun("Left\tCenter\tRight")]
+})
+```
+
+## Constants & Quick Reference
+- **Underlines:** `SINGLE`, `DOUBLE`, `WAVY`, `DASH`
+- **Borders:** `SINGLE`, `DOUBLE`, `DASHED`, `DOTTED`  
+- **Numbering:** `DECIMAL` (1,2,3), `UPPER_ROMAN` (I,II,III), `LOWER_LETTER` (a,b,c)
+- **Tabs:** `LEFT`, `CENTER`, `RIGHT`, `DECIMAL`
+- **Symbols:** `"2022"` (•), `"00A9"` (©), `"00AE"` (®), `"2122"` (™), `"00B0"` (°), `"F070"` (✓), `"F0FC"` (✗)
+
+## Critical Issues & Common Mistakes
+- **CRITICAL: PageBreak must ALWAYS be inside a Paragraph** - standalone PageBreak creates invalid XML that Word cannot open
+- **ALWAYS use ShadingType.CLEAR for table cell shading** - Never use ShadingType.SOLID (causes black background).
+- Measurements in DXA (1440 = 1 inch) | Each table cell needs ≥1 Paragraph | TOC requires HeadingLevel styles only
+- **ALWAYS use custom styles** with Arial font for professional appearance and proper visual hierarchy
+- **ALWAYS set a default font** using `styles.default.document.run.font` - Arial recommended
+- **ALWAYS use columnWidths array for tables** + individual cell widths for compatibility
+- **NEVER use unicode symbols for bullets** - always use proper numbering configuration with `LevelFormat.BULLET` constant (NOT the string "bullet")
+- **NEVER use \n for line breaks anywhere** - always use separate Paragraph elements for each line
+- **ALWAYS use TextRun objects within Paragraph children** - never use text property directly on Paragraph
+- **CRITICAL for images**: ImageRun REQUIRES `type` parameter - always specify "png", "jpg", "jpeg", "gif", "bmp", or "svg"
+- **CRITICAL for bullets**: Must use `LevelFormat.BULLET` constant, not string "bullet", and include `text: "•"` for the bullet character
+- **CRITICAL for numbering**: Each numbering reference creates an INDEPENDENT list. Same reference = continues numbering (1,2,3 then 4,5,6). Different reference = restarts at 1 (1,2,3 then 1,2,3). Use unique reference names for each separate numbered section!
+- **CRITICAL for TOC**: When using TableOfContents, headings must use HeadingLevel ONLY - do NOT add custom styles to heading paragraphs or TOC will break
+- **Tables**: Set `columnWidths` array + individual cell widths, apply borders to cells not table
+- **Set table margins at TABLE level** for consistent cell padding (avoids repetition per cell)