ai-qakit 1.0.0

package/templates/.claude/skills/docs-seeker/scripts/tests/test-fetch-docs.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Tests for fetch-docs.js
+ */
+
+const { buildContext7Url, getUrlVariations } = require('../fetch-docs');
+
+// Test counter
+let passed = 0;
+let failed = 0;
+
+function assert(condition, message) {
+  if (condition) {
+    console.log(`✓ ${message}`);
+    passed++;
+  } else {
+    console.error(`✗ ${message}`);
+    failed++;
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual === expected) {
+    console.log(`✓ ${message}`);
+    passed++;
+  } else {
+    console.error(`✗ ${message}`);
+    console.error(`  Expected: ${expected}`);
+    console.error(`  Actual: ${actual}`);
+    failed++;
+  }
+}
+
+console.log('Running fetch-docs.js tests...\n');
+
+// Test buildContext7Url
+console.log('## Testing buildContext7Url()');
+
+assertEqual(
+  buildContext7Url('vercel/next.js'),
+  'https://context7.com/vercel/next.js/llms.txt',
+  'Build URL for GitHub repo'
+);
+
+assertEqual(
+  buildContext7Url('vercel/next.js', 'cache'),
+  'https://context7.com/vercel/next.js/llms.txt?topic=cache',
+  'Build URL with topic parameter'
+);
+
+assertEqual(
+  buildContext7Url('shadcn-ui/ui', 'date'),
+  'https://context7.com/shadcn-ui/ui/llms.txt?topic=date',
+  'Build URL for shadcn with topic'
+);
+
+// Test getUrlVariations
+console.log('\n## Testing getUrlVariations()');
+
+async function testUrlVariations() {
+  const urls1 = await getUrlVariations('next.js', 'cache');
+  assert(urls1.length >= 2, 'Returns multiple URL variations with topic');
+  assert(urls1[0].includes('?topic=cache'), 'First URL has topic parameter');
+  assert(!urls1[1].includes('?topic='), 'Second URL has no topic parameter');
+
+  const urls2 = await getUrlVariations('shadcn/ui');
+  assert(urls2.length >= 1, 'Returns URL variations without topic');
+  assert(!urls2[0].includes('?topic='), 'URL has no topic parameter');
+
+  const urls3 = await getUrlVariations('astro', 'routing');
+  assert(urls3.length >= 2, 'Returns variations for known library');
+  assertEqual(urls3[0], 'https://context7.com/withastro/astro/llms.txt?topic=routing', 'Maps Astro correctly');
+}
+
+testUrlVariations().then(() => {
+  // Summary
+  console.log('\n## Test Summary');
+  console.log(`Passed: ${passed}`);
+  console.log(`Failed: ${failed}`);
+  console.log(`Total: ${passed + failed}`);
+
+  process.exit(failed > 0 ? 1 : 0);
+});

package/templates/.claude/skills/docs-seeker/scripts/utils/env-loader.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+/**
+ * Environment variable loader for docs-seeker skill
+ * Respects order: process.env > skill/.env > skills/.env > .claude/.env
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse .env file content into key-value pairs
+ * @param {string} content - .env file content
+ * @returns {Object} Parsed environment variables
+ */
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    // Skip comments and empty lines
+    if (!line || line.trim().startsWith('#')) continue;
+
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (match) {
+      const key = match[1];
+      let value = match[2].trim();
+
+      // Remove quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      env[key] = value;
+    }
+  }
+
+  return env;
+}
+
+/**
+ * Load environment variables from .env files in priority order
+ * Priority: process.env > skill/.env > skills/.env > .claude/.env
+ * @returns {Object} Merged environment variables
+ */
+function loadEnv() {
+  const skillDir = path.resolve(__dirname, '../..');
+  const skillsDir = path.resolve(skillDir, '..');
+  const claudeDir = path.resolve(skillsDir, '..');
+
+  const envPaths = [
+    path.join(claudeDir, '.env'),      // Lowest priority
+    path.join(skillsDir, '.env'),
+    path.join(skillDir, '.env'),       // Highest priority (file)
+  ];
+
+  let mergedEnv = {};
+
+  // Load .env files in order (lowest to highest priority)
+  for (const envPath of envPaths) {
+    if (fs.existsSync(envPath)) {
+      try {
+        const content = fs.readFileSync(envPath, 'utf8');
+        const parsed = parseEnvFile(content);
+        mergedEnv = { ...mergedEnv, ...parsed };
+      } catch (error) {
+        // Silently skip unreadable files
+      }
+    }
+  }
+
+  // process.env has highest priority
+  mergedEnv = { ...mergedEnv, ...process.env };
+
+  return mergedEnv;
+}
+
+/**
+ * Get environment variable with fallback
+ * @param {string} key - Environment variable key
+ * @param {string} defaultValue - Default value if not found
+ * @returns {string} Environment variable value
+ */
+function getEnv(key, defaultValue = '') {
+  const env = loadEnv();
+  return env[key] || defaultValue;
+}
+
+module.exports = {
+  loadEnv,
+  getEnv,
+  parseEnvFile,
+};

package/templates/.claude/skills/docs-seeker/workflows/library-search.md

@@ -0,0 +1,87 @@
+# General Library Documentation Search
+
+**Use when:** User asks about entire library/framework
+
+**Speed:** Moderate (30-60s)
+**Token usage:** 🟡 Medium
+**Accuracy:** 📚 Comprehensive
+
+## Trigger Patterns
+
+- "Documentation for [LIBRARY]"
+- "[LIBRARY] getting started"
+- "How to use [LIBRARY]"
+- "[LIBRARY] API reference"
+
+## Workflow (Script-First)
+
+```bash
+# STEP 1: Execute detect-topic.js script
+node scripts/detect-topic.js "<user query>"
+# Returns: {"isTopicSpecific": false} for general queries
+
+# STEP 2: Execute fetch-docs.js script (handles URL construction)
+node scripts/fetch-docs.js "<user query>"
+# Script constructs context7.com URL automatically
+# Script handles GitHub/website URL patterns
+# Returns: llms.txt content with 5-20+ URLs
+
+# STEP 3: Execute analyze-llms-txt.js script
+cat llms.txt | node scripts/analyze-llms-txt.js -
+# Groups URLs: critical, important, supplementary
+# Recommends: agent distribution strategy
+# Returns: {totalUrls, grouped, distribution}
+
+# STEP 4: Deploy agents based on script recommendation
+# - 1-3 URLs: Single agent or direct WebFetch
+# - 4-10 URLs: Deploy 3-5 Explorer agents
+# - 11+ URLs: Deploy 7 agents or phased approach
+
+# STEP 5: Aggregate and present
+# Synthesize findings: installation, concepts, API, examples
+```
+
+## Examples
+
+**Astro framework:**
+```bash
+# Execute scripts (no manual URL construction)
+node scripts/detect-topic.js "Documentation for Astro"
+# {"isTopicSpecific": false}
+
+node scripts/fetch-docs.js "Documentation for Astro"
+# Script fetches: context7.com/withastro/astro/llms.txt
+# Returns: llms.txt with 8 URLs
+
+node scripts/analyze-llms-txt.js < llms.txt
+# {totalUrls: 8, distribution: "3-agents", grouped: {...}}
+
+# Deploy 3 Explorer agents as recommended:
+# Agent 1: Getting started, installation, setup
+# Agent 2: Core concepts, components, layouts
+# Agent 3: Configuration, API reference
+
+# Aggregate and present comprehensive report
+```
+
+## Agent Distribution
+
+**1-3 URLs:** Single agent
+**4-10 URLs:** 3-5 agents (2-3 URLs each)
+**11-20 URLs:** 7 agents (balanced)
+**21+ URLs:** Two-phase (critical first, then important)
+
+## Known Libraries
+
+- Next.js: `vercel/next.js`
+- Astro: `withastro/astro`
+- Remix: `remix-run/remix`
+- shadcn/ui: `shadcn-ui/ui`
+- Better Auth: `better-auth/better-auth`
+
+## Fallback
+
+Scripts handle fallback automatically:
+1. `fetch-docs.js` tries context7.com
+2. If 404, script suggests WebSearch for llms.txt
+3. If still unavailable: [Repository Analysis](./repo-analysis.md)

package/templates/.claude/skills/docs-seeker/workflows/repo-analysis.md

@@ -0,0 +1,91 @@
+# Repository Analysis (No llms.txt)
+
+**Use when:** llms.txt not available on context7.com or official site
+
+**Speed:** Slower (5-10min)
+**Token usage:** 🔴 High
+**Accuracy:** 🔍 Code-based
+
+## When to Use
+
+- Library not on context7.com
+- No llms.txt on official site
+- Need to analyze code structure
+- Documentation incomplete
+
+## Workflow
+
+```
+1. Find repository
+   → WebSearch: "[library] github repository"
+   → Verify: Official, active, has docs/
+
+2. Clone repository
+   → Bash: git clone [repo-url] /tmp/docs-analysis
+   → Optional: checkout specific version/tag
+
+3. Install Repomix (if needed)
+   → Bash: npm install -g repomix
+
+4. Pack repository
+   → Bash: cd /tmp/docs-analysis && repomix --output repomix-output.xml
+   → Repomix creates AI-friendly single file
+
+5. Read packed file
+   → Read: /tmp/docs-analysis/repomix-output.xml
+   → Extract: README, docs/, examples/, API files
+
+6. Analyze structure
+   → Identify: Documentation sections
+   → Extract: Installation, usage, API, examples
+   → Note: Code patterns, best practices
+
+7. Present findings
+   → Source: Repository analysis
+   → Caveat: Based on code, not official docs
+   → Include: Repository health (stars, activity)
+```
+
+## Example
+
+**Obscure library without llms.txt:**
+```bash
+# 1. Find
+WebSearch: "MyLibrary github repository"
+# Found: https://github.com/org/mylibrary
+
+# 2. Clone
+git clone https://github.com/org/mylibrary /tmp/docs-analysis
+
+# 3. Pack with Repomix
+cd /tmp/docs-analysis
+repomix --output repomix-output.xml
+
+# 4. Read
+Read: /tmp/docs-analysis/repomix-output.xml
+# Single XML file with entire codebase
+
+# 5. Extract documentation
+- README.md: Installation, overview
+- docs/: Usage guides, API reference
+- examples/: Code samples
+- src/: Implementation patterns
+
+# 6. Present
+Source: Repository analysis (no llms.txt)
+Health: 1.2K stars, active
+```
+
+## Repomix Benefits
+
+✅ Entire repo in single file
+✅ Preserves directory structure
+✅ AI-optimized format
+✅ Includes metadata
+
+## Alternative
+
+If no GitHub repo exists:
+→ Deploy multiple Researcher agents
+→ Gather: Official site, blog posts, tutorials, Stack Overflow
+→ Note: Quality varies, cross-reference sources

package/templates/.claude/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/templates/.claude/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/templates/.claude/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)