gai-cli-docx 1.0.1

package/README.md

@@ -0,0 +1,57 @@
+---
+name: gai-docx
+description: "CLI tool for converting Markdown to Word documents. Use when: user wants to convert a Markdown file to a .docx Word document."
+homepage: https://github.com/kakkoii1337/gai-cli-docx
+---
+
+# md2word
+
+CLI tool for converting Markdown files to Word documents (.docx).
+
+## Installation
+
+```bash
+npm install -g gai-cli-docx
+```
+
+Or run directly:
+
+```bash
+npx gai-cli-docx "document.md" "output.docx"
+```
+
+## Usage
+
+```bash
+md2word <source-md-file> <dest-docx-file>
+```
+
+### Arguments
+
+- `source-md-file` - Path to the source Markdown file (required)
+- `dest-docx-file` - Path to the output Word document (required)
+
+### Options
+
+- `--help, -h` - Show help message
+
+### Examples
+
+```bash
+# Basic conversion
+md2word "README.md" "output.docx"
+
+# Save to a subdirectory
+md2word "docs/guide.md" "dist/guide.docx"
+```
+
+## Output
+
+Writes a `.docx` Word document to the specified destination path. Prints the output path to stdout on success.
+
+## Notes
+
+- Supports headings (H1–H6), paragraphs, bullet lists, numbered lists, checkboxes, code blocks, inline formatting (bold, italic, code), images, and page breaks
+- Images are resolved relative to the source Markdown file's directory
+- Uses Calibri 11pt with 1.15 line spacing by default
+- Code blocks use Consolas 10pt with grey background shading

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "gai-cli-docx",
+    "version": "1.0.1",
+    "description": "CLI tool for converting Markdown to Word documents",
+    "type": "module",
+    "main": "src/index.js",
+    "bin": {
+        "md2word": "src/index.js"
+    },
+    "scripts": {
+        "start": "node src/index.js"
+    },
+    "keywords": [
+        "cli",
+        "markdown",
+        "word",
+        "docx",
+        "converter"
+    ],
+    "author": "kakkoii1337 <kakkoii1337@gmail.com>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kakkoii1337/gai-cli-docx.git"
+    },
+    "bugs": {
+        "url": "https://github.com/kakkoii1337/gai-cli-docx/issues"
+    },
+    "homepage": "https://github.com/kakkoii1337/gai-cli-docx#readme",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "dependencies": {
+        "docx": "^9.5.1",
+        "image-size": "^2.0.2"
+    }
+}

package/src/convert_md_to_docx.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+convert_md_to_docx.py - Convert markdown to .docx files
+
+Usage:
+    python convert_md_to_docx.py <input.md>
+
+Output:
+    <input>.docx
+
+Features:
+    - Bold (**text**) -> Bold formatting
+    - Italic (*text*) -> Italic formatting
+    - Inline code (`text`) -> Monospace font
+    - Code blocks (```) -> Bordered box with code font
+    - --- -> Page break
+    - Headings -> Document headings (H1-H4)
+    - Lists -> Bullet/numbered lists
+"""
+
+import re
+import sys
+import os
+from docx import Document
+from docx.shared import Pt, RGBColor, Inches
+from docx.oxml.ns import qn
+
+
+def parse_markdown(content):
+    """Parse markdown into structured sections."""
+    sections = []
+    current_section = {"level": 0, "title": "", "content": [], "items": [], "code_blocks": [], "has_page_break": False}
+    
+    in_code_block = False
+    code_lines = []
+    code_lang = ""
+    
+    for line in content.split('\n'):
+        # Handle code blocks
+        if line.strip().startswith('```'):
+            if in_code_block:
+                # End of code block
+                if code_lines:
+                    current_section["code_blocks"].append({
+                        "lang": code_lang,
+                        "code": '\n'.join(code_lines)
+                    })
+                code_lines = []
+                code_lang = ""
+                in_code_block = False
+            else:
+                # Start of code block
+                in_code_block = True
+                code_lang = line.strip()[3:].strip()
+            continue
+        
+        if in_code_block:
+            code_lines.append(line)
+            continue
+        
+        # Detect horizontal rules (page breaks)
+        if re.match(r'^---+\s*$', line):
+            current_section["has_page_break"] = True
+            continue
+        # Detect headings
+        heading_match = re.match(r'^(#{1,6})\s+(.+)$', line)
+        if heading_match:
+            if current_section["title"] or current_section["content"] or current_section["code_blocks"]:
+                sections.append(current_section)
+            current_section = {
+                "level": len(heading_match.group(1)),
+                "title": heading_match.group(2).strip(),
+                "content": [],
+                "items": [],
+                "code_blocks": [],
+                "has_page_break": False
+            }
+        # Detect list items
+        elif re.match(r'^\s*[-*]\s+', line):
+            item = re.sub(r'^\s*[-*]\s+', '', line).strip()
+            current_section["items"].append(item)
+        # Detect numbered items
+        elif re.match(r'^\s*\d+\.\s+', line):
+            item = re.sub(r'^\s*\d+\.\s+', '', line).strip()
+            current_section["items"].append(item)
+        # Regular content
+        elif line.strip():
+            current_section["content"].append(line.strip())
+    
+    if current_section["title"] or current_section["content"] or current_section["code_blocks"]:
+        sections.append(current_section)
+    
+    return sections
+
+
+def add_formatted_paragraph(paragraph, text):
+    """Add text with bold, italic, and inline code formatting."""
+    pattern = r'(\*\*(.+?)\*\*|\*(.+?)\*|`(.+?)`)'
+    
+    last_end = 0
+    for match in re.finditer(pattern, text):
+        if match.start() > last_end:
+            plain_text = text[last_end:match.start()]
+            if plain_text:
+                paragraph.add_run(plain_text)
+        
+        if match.group(2):  # **bold**
+            run = paragraph.add_run(match.group(2))
+            run.bold = True
+        elif match.group(3):  # *italic*
+            run = paragraph.add_run(match.group(3))
+            run.italic = True
+        elif match.group(4):  # `code`
+            run = paragraph.add_run(match.group(4))
+            run.font.name = 'Consolas'
+            run.font.size = Pt(9)
+        
+        last_end = match.end()
+    
+    if last_end < len(text):
+        plain_text = text[last_end:]
+        if plain_text:
+            paragraph.add_run(plain_text)
+
+
+def add_code_block(doc, code_text, lang=""):
+    """Add a code block with border and monospace font."""
+    p = doc.add_paragraph()
+    
+    # Set paragraph border
+    pPr = p._p.get_or_add_pPr()
+    pBdr = pPr.makeelement(qn('w:pBdr'), {})
+    for side in ['top', 'left', 'bottom', 'right']:
+        bdr = pBdr.makeelement(qn(f'w:{side}'), {
+            qn('w:val'): 'single',
+            qn('w:sz'): '4',
+            qn('w:space'): '4',
+            qn('w:color'): '999999',
+        })
+        pBdr.append(bdr)
+    pPr.append(pBdr)
+    
+    # Set paragraph shading (light gray background)
+    shd = pPr.makeelement(qn('w:shd'), {
+        qn('w:val'): 'clear',
+        qn('w:color'): 'auto',
+        qn('w:fill'): 'F5F5F5',
+    })
+    pPr.append(shd)
+    
+    # Add language label if present
+    if lang:
+        run = p.add_run(f"{lang}\n")
+        run.font.name = 'Consolas'
+        run.font.size = Pt(8)
+        run.font.color.rgb = RGBColor(128, 128, 128)
+        run.italic = True
+    
+    # Add code content
+    run = p.add_run(code_text)
+    run.font.name = 'Consolas'
+    run.font.size = Pt(9)
+    
+    # Set left indent to give some padding
+    p.paragraph_format.left_indent = Inches(0.2)
+    p.paragraph_format.space_after = Pt(6)
+
+
+def create_docx(sections, output_path):
+    """Create a Word document from parsed sections."""
+    doc = Document()
+    
+    # Add title
+    if sections and sections[0]["title"]:
+        doc.add_heading(sections[0]["title"], level=0)
+    
+    for section in sections[1:]:
+        if not section["title"]:
+            continue
+            
+        # Add page break if needed
+        if section["has_page_break"]:
+            doc.add_page_break()
+        
+        # Add heading
+        doc.add_heading(section["title"], level=min(section["level"], 4))
+        
+        # Add content paragraphs
+        for para in section["content"]:
+            if para:
+                p = doc.add_paragraph()
+                add_formatted_paragraph(p, para)
+        
+        # Add code blocks
+        for code_block in section["code_blocks"]:
+            add_code_block(doc, code_block["code"], code_block["lang"])
+        
+        # Add list items
+        for item in section["items"]:
+            if item:
+                p = doc.add_paragraph(style='List Bullet')
+                add_formatted_paragraph(p, item)
+    
+    doc.save(output_path)
+    print(f"Created: {output_path}")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python convert_md_to_docx.py <input.md>")
+        sys.exit(1)
+    
+    input_path = sys.argv[1]
+    output_dir = os.path.dirname(input_path) if os.path.dirname(input_path) else "."
+    base_name = os.path.splitext(os.path.basename(input_path))[0]
+    
+    with open(input_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    sections = parse_markdown(content)
+    
+    docx_path = os.path.join(output_dir, base_name + ".docx")
+    create_docx(sections, docx_path)
+
+
+if __name__ == '__main__':
+    main()

package/src/index.js

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+/**
+ * gai-cli-msword - CLI tool for converting Markdown to Word documents
+ *
+ * Usage: md2word <source-md-file> <dest-docx-file>
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import sizeOf from "image-size";
+import {
+    Document,
+    Packer,
+    Paragraph,
+    TextRun,
+    HeadingLevel,
+    CheckBox,
+    ImageRun,
+    BorderStyle,
+} from "docx";
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+
+    for (const arg of args) {
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+    }
+
+    if (args.length !== 2) {
+        console.error("Error: Exactly two arguments required");
+        printHelp();
+        process.exit(1);
+    }
+
+    const [sourcePath, destPath] = args;
+
+    if (!existsSync(sourcePath)) {
+        console.error(`Error: Source file "${sourcePath}" does not exist`);
+        process.exit(1);
+    }
+
+    return { sourcePath, destPath };
+}
+
+function printHelp() {
+    console.log(`
+md2word - CLI tool for converting Markdown to Word documents
+
+Usage: md2word <source-md-file> <dest-docx-file>
+
+Arguments:
+  source-md-file       Path to the source Markdown file (required)
+  dest-docx-file       Path to the output Word document (required)
+
+Options:
+  --help, -h           Show this help message
+
+Examples:
+  md2word "README.md" "output.docx"
+  md2word "docs/guide.md" "dist/guide.docx"
+`);
+}
+
+function parseMarkdownToDocx(markdown) {
+    const lines = markdown.split("\n");
+    const elements = [];
+    let currentCodeBlock = [];
+    let inCodeBlock = false;
+    let codeBlockLanguage = "";
+    let codeBlockIndent = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Handle horizontal rule (page break)
+        if (line.trim() === "---") {
+            while (
+                elements.length > 0 &&
+                elements[elements.length - 1].type === "emptyLine"
+            ) {
+                elements.pop();
+            }
+
+            elements.push({ type: "pageBreak", content: "" });
+
+            while (i + 1 < lines.length && lines[i + 1].trim() === "") {
+                i++;
+            }
+            continue;
+        }
+
+        // Handle code blocks (including indented ones)
+        if (line.trim().startsWith("```")) {
+            if (inCodeBlock) {
+                elements.push({
+                    type: "codeBlock",
+                    content: currentCodeBlock.join("\n"),
+                    language: codeBlockLanguage,
+                    indent: codeBlockIndent,
+                });
+                currentCodeBlock = [];
+                inCodeBlock = false;
+                codeBlockLanguage = "";
+                codeBlockIndent = 0;
+            } else {
+                const trimmedLine = line.trim();
+                codeBlockLanguage = trimmedLine.substring(3).trim();
+                inCodeBlock = true;
+                const leadingSpaces = line.match(/^(\s*)/)[1].length;
+                codeBlockIndent = Math.floor(leadingSpaces / 4);
+            }
+            continue;
+        }
+
+        if (inCodeBlock) {
+            currentCodeBlock.push(line);
+            continue;
+        }
+
+        // Handle headings
+        if (line.startsWith("#")) {
+            const level = line.match(/^#+/)[0].length;
+            const text = line.substring(level).trim();
+            elements.push({ type: "heading", level, content: text });
+            continue;
+        }
+
+        // Handle bullet lists (including checkboxes)
+        if (line.match(/^\s*[-*+]\s+/)) {
+            const indent = line.match(/^\s*/)[0].length;
+            let text = line.replace(/^\s*[-*+]\s+/, "");
+
+            let isCheckbox = false;
+            let isChecked = false;
+
+            if (text.startsWith("[ ] ")) {
+                isCheckbox = true;
+                isChecked = false;
+                text = text.substring(4);
+            } else if (text.startsWith("[x] ") || text.startsWith("[X] ")) {
+                isCheckbox = true;
+                isChecked = true;
+                text = text.substring(4);
+            }
+
+            elements.push({
+                type: isCheckbox ? "checkboxItem" : "listItem",
+                content: text,
+                indent: Math.floor(indent / 4),
+                checked: isChecked,
+            });
+            continue;
+        }
+
+        // Handle numbered lists
+        if (line.match(/^\s*\d+\.\s+/)) {
+            const indent = line.match(/^\s*/)[0].length;
+            const numberMatch = line.match(/^\s*(\d+)\.\s+/);
+            const originalNumber = numberMatch[1];
+            const text = line.replace(/^\s*\d+\.\s+/, "");
+            elements.push({
+                type: "numberedListItem",
+                content: text,
+                indent: Math.floor(indent / 4),
+                originalNumber,
+            });
+            continue;
+        }
+
+        // Handle images
+        if (line.match(/^\s*!\[[^\]]*\]\([^)]+\)\s*$/)) {
+            const indent = line.match(/^\s*/)[0].length;
+            const imageMatch = line.match(/^\s*!\[([^\]]*)\]\(([^)]+)\)\s*$/);
+            if (imageMatch) {
+                elements.push({
+                    type: "image",
+                    content: imageMatch[1],
+                    path: imageMatch[2],
+                    indent: Math.floor(indent / 4),
+                });
+            }
+            continue;
+        }
+
+        // Handle regular paragraphs and empty lines
+        if (line.trim() !== "") {
+            elements.push({ type: "paragraph", content: line.trim() });
+        } else {
+            elements.push({ type: "emptyLine", content: "" });
+        }
+    }
+
+    return elements;
+}
+
+function createDocxElements(parsedElements, sourcePath) {
+    const docxElements = [];
+
+    for (const element of parsedElements) {
+        switch (element.type) {
+            case "heading": {
+                const headingLevel = Math.min(element.level, 6);
+                docxElements.push(
+                    new Paragraph({
+                        children: [new TextRun(element.content)],
+                        heading:
+                            headingLevel === 1 ? HeadingLevel.HEADING_1
+                            : headingLevel === 2 ? HeadingLevel.HEADING_2
+                            : headingLevel === 3 ? HeadingLevel.HEADING_3
+                            : headingLevel === 4 ? HeadingLevel.HEADING_4
+                            : headingLevel === 5 ? HeadingLevel.HEADING_5
+                            : HeadingLevel.HEADING_6,
+                        spacing: { before: 240, after: 120 },
+                    })
+                );
+                break;
+            }
+
+            case "paragraph": {
+                const runs = parseInlineFormatting(element.content);
+                docxElements.push(
+                    new Paragraph({ children: runs, spacing: { after: 120 } })
+                );
+                break;
+            }
+
+            case "listItem": {
+                const runs = parseInlineFormatting(element.content);
+                docxElements.push(
+                    new Paragraph({
+                        children: [new TextRun("•\t"), ...runs],
+                        indent: { left: (element.indent + 1) * 360, hanging: 360 },
+                        tabStops: [{ type: "left", position: (element.indent + 1) * 360 }],
+                        spacing: { after: 60 },
+                    })
+                );
+                break;
+            }
+
+            case "checkboxItem": {
+                const runs = parseInlineFormatting(element.content);
+                docxElements.push(
+                    new Paragraph({
+                        children: [
+                            new CheckBox({ checked: element.checked }),
+                            new TextRun("\t"),
+                            ...runs,
+                        ],
+                        indent: { left: (element.indent + 1) * 360, hanging: 360 },
+                        tabStops: [{ type: "left", position: (element.indent + 1) * 360 }],
+                        spacing: { after: 60 },
+                    })
+                );
+                break;
+            }
+
+            case "numberedListItem": {
+                const runs = parseInlineFormatting(element.content);
+                docxElements.push(
+                    new Paragraph({
+                        children: [new TextRun(`${element.originalNumber}.\t`), ...runs],
+                        indent: { left: (element.indent + 1) * 360, hanging: 360 },
+                        tabStops: [{ type: "left", position: (element.indent + 1) * 360 }],
+                        spacing: { after: 60 },
+                    })
+                );
+                break;
+            }
+
+            case "codeBlock": {
+                const codeLines = element.content.split("\n");
+                const children = [];
+
+                if (element.language) {
+                    children.push(new TextRun({
+                        text: element.language,
+                        font: "Consolas",
+                        size: 16,
+                        color: "808080",
+                        italics: true,
+                    }));
+                    children.push(new TextRun({ break: 1 }));
+                }
+
+                codeLines.forEach((codeLine, idx) => {
+                    if (idx > 0) children.push(new TextRun({ break: 1 }));
+                    children.push(new TextRun({
+                        text: codeLine || " ",
+                        font: "Consolas",
+                        size: 18,
+                    }));
+                });
+
+                const borderOpts = { style: BorderStyle.SINGLE, size: 4, space: 4, color: "999999" };
+                docxElements.push(
+                    new Paragraph({
+                        children,
+                        border: { top: borderOpts, bottom: borderOpts, left: borderOpts, right: borderOpts },
+                        shading: { fill: "F5F5F5" },
+                        indent: { left: 288 },
+                        spacing: { after: 120 },
+                    })
+                );
+                break;
+            }
+
+            case "pageBreak": {
+                docxElements.push(
+                    new Paragraph({
+                        children: [],
+                        pageBreakBefore: true,
+                        spacing: { before: 0, after: 0 },
+                    })
+                );
+                break;
+            }
+
+            case "emptyLine": {
+                docxElements.push(new Paragraph({ text: "", spacing: { after: 60 } }));
+                break;
+            }
+
+            case "image": {
+                try {
+                    const markdownDir = dirname(resolve(sourcePath));
+                    const absoluteImagePath = resolve(markdownDir, element.path);
+
+                    if (existsSync(absoluteImagePath)) {
+                        const imageBuffer = readFileSync(absoluteImagePath);
+
+                        let scaledWidth, scaledHeight;
+                        try {
+                            const dimensions = sizeOf(imageBuffer);
+                            const maxWidth = 400;
+                            const scaleFactor = Math.min(maxWidth / dimensions.width, 1);
+                            scaledWidth = Math.round(dimensions.width * scaleFactor);
+                            scaledHeight = Math.round(dimensions.height * scaleFactor);
+                        } catch {
+                            scaledWidth = 400;
+                            scaledHeight = 300;
+                        }
+
+                        docxElements.push(
+                            new Paragraph({
+                                children: [
+                                    new ImageRun({
+                                        data: imageBuffer,
+                                        transformation: { width: scaledWidth, height: scaledHeight },
+                                        type: "png",
+                                    }),
+                                ],
+                                indent: { left: element.indent * 360 },
+                            })
+                        );
+                    }
+                } catch {
+                    // Silently skip image on error
+                }
+                break;
+            }
+        }
+    }
+
+    return docxElements;
+}
+
+function parseInlineFormatting(text) {
+    const runs = [];
+    let currentText = "";
+    let i = 0;
+
+    while (i < text.length) {
+        // Handle bold (**text**)
+        if (text.substr(i, 2) === "**") {
+            if (currentText) {
+                runs.push(new TextRun(currentText));
+                currentText = "";
+            }
+            i += 2;
+            const endIndex = text.indexOf("**", i);
+            if (endIndex !== -1) {
+                runs.push(new TextRun({ text: text.substring(i, endIndex), bold: true }));
+                i = endIndex + 2;
+            } else {
+                currentText += "**";
+            }
+            continue;
+        }
+
+        // Handle italic (*text*)
+        if (text[i] === "*" && text.substr(i, 2) !== "**") {
+            if (currentText) {
+                runs.push(new TextRun(currentText));
+                currentText = "";
+            }
+            i += 1;
+            const endIndex = text.indexOf("*", i);
+            if (endIndex !== -1) {
+                runs.push(new TextRun({ text: text.substring(i, endIndex), italics: true }));
+                i = endIndex + 1;
+            } else {
+                currentText += "*";
+            }
+            continue;
+        }
+
+        // Handle inline code (`text`)
+        if (text[i] === "`") {
+            if (currentText) {
+                runs.push(new TextRun(currentText));
+                currentText = "";
+            }
+            i += 1;
+            const endIndex = text.indexOf("`", i);
+            if (endIndex !== -1) {
+                runs.push(
+                    new TextRun({
+                        text: text.substring(i, endIndex),
+                        font: "Consolas",
+                        shading: { fill: "F5F5F5" },
+                    })
+                );
+                i = endIndex + 1;
+            } else {
+                currentText += "`";
+            }
+            continue;
+        }
+
+        currentText += text[i];
+        i++;
+    }
+
+    if (currentText) {
+        runs.push(new TextRun(currentText));
+    }
+
+    return runs.length > 0 ? runs : [new TextRun("")];
+}
+
+async function main() {
+    const { sourcePath, destPath } = parseArgs();
+
+    console.error(`Converting ${sourcePath} to ${destPath}...`);
+
+    const markdownContent = readFileSync(sourcePath, "utf-8");
+    const parsedElements = parseMarkdownToDocx(markdownContent);
+    const docxElements = createDocxElements(parsedElements, sourcePath);
+
+    const doc = new Document({
+        styles: {
+            paragraphStyles: [
+                {
+                    id: "default",
+                    name: "Default",
+                    basedOn: "Normal",
+                    next: "default",
+                    run: {
+                        size: 22,
+                        font: "Calibri",
+                    },
+                    paragraph: {
+                        spacing: {
+                            line: 276,
+                            lineRule: "auto",
+                        },
+                    },
+                },
+            ],
+        },
+        sections: [{ children: docxElements }],
+    });
+
+    const buffer = await Packer.toBuffer(doc);
+
+    const destDir = dirname(resolve(destPath));
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+
+    writeFileSync(destPath, buffer);
+    console.log(destPath);
+}
+
+main().catch((error) => {
+    console.error("Error:", error.message);
+    process.exit(1);
+});

package/test/hdwallet.md

@@ -0,0 +1,314 @@
+# Hierarchical Deterministic (HD) Wallets
+
+📌 **NOTE: This assignment is compulsory. You need to complete this in order to generate your own mnemonic phrase in a .env file which will be used for future labs.**
+
+## 1. From Keys to Wallets
+
+We have learnt that an Ethereum account is represented by an address derived from a private key. In practice, however, users often need many addresses — for privacy, account separation, or interacting with different apps. Since private keys are cryptic, managing dozens of unrelated private keys would be cumbersome and risky. To solve this, modern wallets use a system called Hierarchical Deterministic (HD) wallets, which can generate and manage unlimited addresses from a single master seed.
+
+### Core Concepts
+
+HD Wallets use cryptographic principles to generate multiple addresses from a single seed phrase (mnemonic). This system provides:
+
+-   **Deterministic Generation**: Same seed always produces same address sequence
+-   **Infinite Addresses**: Can generate unlimited addresses from one seed
+-   **Backup Simplicity**: One mnemonic backs up entire wallet
+-   **Cross-Wallet Compatibility**: Standard ensures wallet interoperability
+
+### Mnemonic Seed Phrases
+
+Typically consist of 12 or 24 words that encode the master seed for address generation. Each word comes from a standardized list of 2048 words (BIP39 standard).
+
+### Protecting Your Mnemonic
+
+This mnemonic phrase is imported into wallet software to generate your private keys and addresses, for example, Metamask. But sometimes, we may need to save the mnemonic in server-side applications such as Hardhat Network for automated tasks like contract deployment or scheduled transactions.
+
+The mnemonic we generated from the Lab Practice is sensitive information that should not be stored as plain text in the config file or hard-coded in your code base.
+
+-   **Single Point of Failure**: Compromised mnemonic exposes all derived addresses
+-   **Backup Critical**: Loss of mnemonic means loss of all funds
+-   **Storage Best Practices**: Never store digitally, use secure physical storage
+
+In the following lab, we will learn how to use the `dotenv` package to securely manage environment variables like mnemonics.
+
+---
+
+## 🛠️ Lab Practice: Using Mnemonic Phrase
+
+In this lab, we will learn how to configure HD wallets in Hardhat Network and manage mnemonics securely using environment variables.
+
+Hardhat uses a well-known default mnemonic for its local network:
+
+```txt
+test test test test test test test test test test test junk
+```
+
+We will prove that this is indeed the default mnemonic by comparing the addresses generated from this mnemonic with the accounts provided by Hardhat Network.
+
+### Step 1: Start Hardhat Local Node
+
+-   **Install packages**
+
+    ```bash
+    cd /workspace/day-1/home-assignments/06-hd-wallet
+    npm i
+    ```
+
+-   **Startup Hardhat Standalone Network**
+
+    If the node is already running from previous lab, press `Ctrl+C` to stop it first before starting again.
+
+    ```bash
+     hh node
+
+     # Output:
+
+     # Accounts
+     # ========
+     #
+     # WARNING: These accounts, and their private keys, are publicly known.
+     # Any funds sent to them on Mainnet or any other live network WILL BE  # LOST.
+     #
+     # Account #0: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 (10000 ETH)
+     # Private Key:  # 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+    ```
+
+    Keep this running till the end of this lab as we want to compare the addresses generated from the mnemonic after we set it in the config file.
+
+### Step 2: Configure Hardhat Network with Default Mnemonic
+
+-   **Set Mnemonic Phrase for Hardhat Network**
+
+    Open hardhat.config.js and add a **hardhat** network configuration with
+    the mnemonic "test test test test test test test test test test test junk"
+
+    ```javascript
+    module.exports = {
+        solidity: "0.8.20",
+        networks: {
+            localhost: {
+                url: "http://localhost:8545",
+            },
+            hardhat: {
+                accounts: {
+                    mnemonic:
+                        "test test test test test test test test test test test junk",
+                },
+            },
+        },
+    };
+    ```
+
+-   **Start Hardhat Console**
+
+    Open a parallel terminal window and run:
+
+    ```bash
+    hh console
+    ```
+
+    NOTE: Do not connect to localhost because we want to use the Hardhat Network built-in provider which uses the mnemonic we just set in the config file.
+
+-   **Get account addresses**
+
+    In the Hardhat console, run the following command to address of the first account:
+
+    ```js
+    > const { ethers } = require("hardhat");
+    > accounts = await ethers.getSigners();
+    > accounts[0].address
+    // '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'
+
+    ```
+
+    Compare this address with the first account address printed in the Hardhat Node terminal. They should match.
+
+### Step 3: Generate Custom Mnemonic and Configure Hardhat Network
+
+**NOTE:📌** This is the most important part of this lab. Please follow the instructions carefully.
+
+-   **Generate New Mnemonic Phrase**
+
+    In the Hardhat console, run the following commands line by line after the `>` prompt to generate a new mnemonic phrase:
+
+    ```js
+    > mnemonic = ethers.Wallet.createRandom().mnemonic.phrase;
+
+    // Sample Output:
+    // 'hill drive sure whip bargain horn raven sunny claw example merit income'
+    ```
+
+    Record the generated mnemonic as we will need it in the next step.
+
+    Type "CTRL+C" to exit the Hardhat console.
+
+-   **Install dotenv package**
+
+    We need to install a package called `dotenv` that allow us to load environment variables from a `.env` file.
+
+    ```bash
+    npm i dotenv
+    ```
+
+-   **Create .env file**
+    Create a file named `.env` in the lesson directory and add the following content:
+
+    ```env
+    FIN556_MNEMONIC="your mnemonic phrase here"
+    ```
+
+    Replace `your mnemonic phrase here` with the mnemonic you generated earlier.
+
+-   **Update hardhat.config.js**
+
+    Open `hardhat.config.js`.
+
+    Replace the mnemonic in the **hardhat** network configuration from this:
+
+    ```javascript
+    mnemonic:
+        "test test test test test test test test test test test junk",
+    ```
+
+    to this:
+
+    ```javascript
+    mnemonic: process.env.FIN556_MNEMONIC,
+    ```
+
+### Step 4: Verify New Mnemonic is Used
+
+-   **Restart Hardhat Console**
+
+    ```bash
+    hh console
+    ```
+
+-   **Get account addresses again**
+
+    In the Hardhat console, run the following command to address of the first account:
+
+    ```js
+    > const { ethers } = require("hardhat");
+    > accounts = await ethers.getSigners();
+    > accounts[0].address
+
+    // '0x...' Your new address from the new mnemonic will show here
+
+    ```
+
+    Compare this address with the first account address printed in the Hardhat Node terminal. They will not match because we have changed the mnemonic.
+
+**NOTE:📌** Pay attention to the **".env"** file and **hardhat.config.js** changes you made in this lab. It will be used in future labs.
+
+---
+
+## 2. Derivation Paths
+
+You may have noticed that Hardhat Local Node generates 20 accounts by default. And each time you run the following commands:
+
+```js
+const accounts = await ethers.getSigners();
+accounts[0].address
+accounts[1].address
+accounts[2].address
+...
+```
+
+You get the same 20 addresses.
+
+That is because unlike a single private key wallet, HD wallets can generate multiple addresses from the same mnemonic using a concept called derivation paths.
+
+Addresses are generated using derivation paths like `m/44'/60'/0'/0` where:
+
+-   `m`: Master key
+-   `44'`: Purpose (HD wallets)
+-   `60'`: Coin type (Ethereum)
+-   `0'`: Account index
+-   `0`: Change index (external addresses)
+
+By changing the last segment of the derivation path, we can generate different addresses from the same mnemonic.
+
+For example, the first three addresses are derived using the following paths:
+
+-   First address: `m/44'/60'/0'/0/0`
+-   Second address: `m/44'/60'/0'/0/1`
+-   Third address: `m/44'/60'/0'/0/2`
+
+Notice how only the last segment changes to generate different addresses.
+
+---
+
+## 🛠️ Lab Practice: Using Derivation Paths
+
+-   **Start Hardhat Console**
+
+    ```bash
+    hh console
+    ```
+
+-   **Generate New Mnemonic Phrase**
+
+    Generate a new mnemonic phrase and save it into a variable:
+
+    ```js
+    > const { ethers } = require("ethers");
+    > mnemonic = ethers.Wallet.createRandom().mnemonic.phrase;
+
+    // Sample Output:
+    // 'hill drive sure whip bargain horn raven sunny claw example merit income'
+    ```
+
+-   **Generate Accounts**
+
+    Use the generated mnemonic to derive the first three Ethereum accounts using the standard derivation path `m/44'/60'/0'/0/n` where `n` is the account index (0, 1, 2).
+
+    ```js
+
+    // Derive the first account (Ethereum derivation path: m/44'/60'/0'/0/0)
+
+    > const wallet0 = ethers.HDNodeWallet.fromPhrase(
+        mnemonic,
+        null,
+        "m/44'/60'/0'/0/0"
+    );
+    > wallet0.address
+
+    // Sample Output:
+    // '0x18b2Ba693Fc01A6e7e6031e5a31936AC8ED8Aef5'
+
+    // ------------------------------------------------------------------
+
+    // Derive the second account (m/44'/60'/0'/0/1)
+
+    > const wallet1 = ethers.HDNodeWallet.fromPhrase(
+        mnemonic,
+        null,
+        "m/44'/60'/0'/0/1"
+    );
+    > wallet1.address
+
+    // Sample Output:
+    // '0x1B1256AD2F06d73F44C211660124c3d1ad706369'
+
+    // ------------------------------------------------------------------
+
+    // Derive the third account (m/44'/60'/0'/0/2)
+
+    > const wallet2 = ethers.HDNodeWallet.fromPhrase(
+        mnemonic,
+        null,
+        "m/44'/60'/0'/0/2"
+    );
+    > wallet2.address
+
+    // Sample Output:
+    //'0x56EDa570299e4e28B8dA016E1eFABc2FB8872A4f'
+
+    ```
+
+    Record the generated mnemonic and the first three account addresses.
+
+    You can see that by changing the last segment of the derivation path, we can generate different addresses from the same mnemonic.
+
+-   **Task Completed ✅**

package/test/test.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+INPUT="$SCRIPT_DIR/hdwallet.md"
+OUTPUT="$SCRIPT_DIR/hdwallet.docx"
+
+# Install dependencies if needed
+if [ ! -d "$PROJECT_DIR/node_modules" ]; then
+    echo "Installing dependencies..."
+    (cd "$PROJECT_DIR" && npm install)
+fi
+
+# Remove any previous output
+rm -f "$OUTPUT"
+
+# Run the conversion
+echo "Running: node src/index.js test/hdwallet.md test/hdwallet.docx"
+node "$PROJECT_DIR/src/index.js" "$INPUT" "$OUTPUT"
+
+# Verify the output file was created
+if [ -f "$OUTPUT" ]; then
+    SIZE=$(wc -c < "$OUTPUT")
+    echo "OK: $OUTPUT created ($SIZE bytes)"
+else
+    echo "FAIL: $OUTPUT was not created"
+    exit 1
+fi