feat: Add Notion import support via NOTION_PAGE_ID env var

- Add ENABLE_NOTION_IMPORT flag in Dockerfile
- Add notion:import script in package.json
- Modify notion-importer to use NOTION_PAGE_ID env var directly
- Auto-extract title and generate slug from Notion page
- Add comprehensive French documentation in NOTION_IMPORT.md

Dockerfile

@@ -0,0 +1,82 @@
+# Use an official Node runtime as the base image for building the application
+# Build with Playwright (browsers and deps ready)
+FROM mcr.microsoft.com/playwright:v1.55.0-jammy AS build
+
+# Install git, git-lfs, and dependencies for Pandoc (only if ENABLE_LATEX_CONVERSION=true)
+RUN apt-get update && apt-get install -y git git-lfs wget && apt-get clean
+
+# Install latest Pandoc from GitHub releases (only installed if needed later)
+RUN wget -qO- https://github.com/jgm/pandoc/releases/download/3.8/pandoc-3.8-linux-amd64.tar.gz | tar xzf - -C /tmp && \
+    cp /tmp/pandoc-3.8/bin/pandoc /usr/local/bin/ && \
+    cp /tmp/pandoc-3.8/bin/pandoc-lua /usr/local/bin/ && \
+    rm -rf /tmp/pandoc-3.8
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy package.json and package-lock.json
+COPY app/package*.json ./
+
+# Install dependencies
+RUN npm install
+
+# Copy the rest of the application code
+COPY app/ .
+
+# Conditionally convert LaTeX to MDX if ENABLE_LATEX_CONVERSION=true
+ARG ENABLE_LATEX_CONVERSION=false
+RUN if [ "$ENABLE_LATEX_CONVERSION" = "true" ]; then \
+    echo "🔄 LaTeX importer enabled - running latex:convert..."; \
+    npm run latex:convert; \
+    else \
+    echo "⏭️  LaTeX importer disabled - skipping..."; \
+    fi
+
+# Conditionally import from Notion if ENABLE_NOTION_IMPORT=true
+ARG ENABLE_NOTION_IMPORT=false
+ARG NOTION_TOKEN
+ARG NOTION_PAGE_ID
+RUN if [ "$ENABLE_NOTION_IMPORT" = "true" ]; then \
+    echo "🔄 Notion importer enabled - running notion:import..."; \
+    npm run notion:import; \
+    else \
+    echo "⏭️  Notion importer disabled - skipping..."; \
+    fi
+
+# Ensure `public/data` is a real directory with real files (not a symlink)
+# This handles the case where `public/data` is a symlink in the repo, which
+# would be broken inside the container after COPY.
+RUN set -e; \
+    if [ -e public ] && [ ! -d public ]; then rm -f public; fi; \
+    mkdir -p public; \
+    if [ -L public/data ] || { [ -e public/data ] && [ ! -d public/data ]; }; then rm -f public/data; fi; \
+    mkdir -p public/data; \
+    cp -a src/content/assets/data/. public/data/
+
+# Build the application
+RUN npm run build
+
+# Generate the PDF (light theme, full wait)
+RUN npm run export:pdf -- --theme=light --wait=full
+
+# Use an official Nginx runtime as the base image for serving the application
+FROM nginx:alpine
+
+# Copy the built application from the build stage
+COPY --from=build /app/dist /usr/share/nginx/html
+
+# Copy a custom Nginx configuration file
+COPY nginx.conf /etc/nginx/nginx.conf
+
+# Create necessary directories and set permissions
+RUN mkdir -p /var/cache/nginx /var/run /var/log/nginx && \
+    chmod -R 777 /var/cache/nginx /var/run /var/log/nginx /etc/nginx/nginx.conf
+
+# Switch to non-root user
+USER nginx
+
+# Expose port 8080
+EXPOSE 8080
+
+# Command to run the application
+CMD ["nginx", "-g", "daemon off;"]

NOTION_IMPORT.md

@@ -0,0 +1,186 @@
+# 📖 Guide d'importation depuis Notion
+
+Ce guide explique comment configurer l'importation automatique depuis Notion lors du build de votre Space HuggingFace.
+
+## 🎯 Principe de fonctionnement
+
+Lors du build Docker sur HuggingFace Spaces, si les variables d'environnement sont configurées :
+1. Le script va chercher votre page Notion
+2. Extrait automatiquement le titre et génère le slug
+3. Convertit le contenu en MDX
+4. Build l'application avec le nouveau contenu
+
+**Avantage :** Vous modifiez votre article dans Notion, puis vous cliquez sur "Factory Reboot" dans HF Spaces → le site est automatiquement mis à jour !
+
+## ⚙️ Configuration sur HuggingFace Spaces
+
+### 1. Créer une intégration Notion
+
+1. Allez sur https://www.notion.so/my-integrations
+2. Cliquez sur "New integration"
+3. Donnez un nom (ex: "HF Article Importer")
+4. Sélectionnez votre workspace
+5. Cliquez sur "Submit"
+6. **Copiez le token** (format: `secret_xxxxx...`)
+
+### 2. Partager votre page Notion avec l'intégration
+
+1. Ouvrez votre page Notion
+2. Cliquez sur "Share" (en haut à droite)
+3. Cliquez sur "Invite"
+4. Recherchez le nom de votre intégration
+5. Sélectionnez-la et donnez la permission "Can read content"
+6. Cliquez sur "Invite"
+
+### 3. Récupérer l'ID de votre page Notion
+
+L'ID se trouve dans l'URL de votre page :
+```
+https://www.notion.so/Mon-Article-27877f1c9c9d804d9c82f7b3905578ff
+                                └─────────────────┬─────────────────┘
+                                           C'est cet ID !
+```
+
+Exemple : `27877f1c9c9d804d9c82f7b3905578ff`
+
+### 4. Configurer les variables d'environnement sur HF Spaces
+
+1. Allez dans les Settings de votre Space
+2. Section "Repository secrets"
+3. Ajoutez ces 3 variables :
+
+| Variable | Valeur | Secret ? |
+|----------|--------|----------|
+| `ENABLE_NOTION_IMPORT` | `true` | Non |
+| `NOTION_TOKEN` | `secret_xxx...` | **Oui** ✅ |
+| `NOTION_PAGE_ID` | `27877f1c...` | Non |
+
+**Important :** Cochez la case "Secret" pour `NOTION_TOKEN` uniquement !
+
+### 5. Rebuild votre Space
+
+1. Allez dans l'onglet "Settings"
+2. Cliquez sur "Factory reboot"
+3. Attendez le rebuild (~5-10 minutes)
+4. Votre article Notion est maintenant publié ! 🎉
+
+## 🔄 Workflow de mise à jour
+
+```
+┌─────────────────────────┐
+│ 1. Éditez dans Notion   │
+│    (brouillon privé)    │
+└───────────┬─────────────┘
+            │
+            ↓
+┌─────────────────────────┐
+│ 2. Vérifiez le contenu  │
+│    (preview Notion)     │
+└───────────┬─────────────┘
+            │
+            ↓
+┌─────────────────────────┐
+│ 3. HF Spaces →          │
+│    "Factory Reboot"     │
+└───────────┬─────────────┘
+            │
+            ↓
+┌─────────────────────────┐
+│ 4. Attendez 5-10 min    │
+│    (build Docker)       │
+└───────────┬─────────────┘
+            │
+            ↓
+┌─────────────────────────┐
+│ 5. Site mis à jour ! ✅ │
+│    (zéro downtime)      │
+└─────────────────────────┘
+```
+
+## 🧪 Test en local
+
+Avant de publier, vous pouvez tester en local :
+
+```bash
+# 1. Créer un fichier .env dans app/scripts/notion-importer/
+cd app/scripts/notion-importer
+cp env.example .env
+
+# 2. Éditer .env avec vos credentials
+# NOTION_TOKEN=secret_xxx
+# NOTION_PAGE_ID=abc123
+
+# 3. Installer les dépendances
+npm install
+
+# 4. Lancer l'import
+node index.mjs
+
+# 5. Le contenu est copié dans app/src/content/article.mdx
+# Les images dans app/src/content/assets/image/
+
+# 6. Lancer le serveur de dev Astro
+cd ../..  # Retour à app/
+npm run dev
+
+# 7. Ouvrir http://localhost:4321
+```
+
+## 📋 Fonctionnalités supportées
+
+### ✅ Supporté automatiquement
+- Texte formaté (gras, italique, code inline)
+- Titres (h1, h2, h3, etc.)
+- Listes (ordonnées, non-ordonnées)
+- Images (téléchargées et converties)
+- Liens externes
+- Blocs de code avec syntaxe
+- Callouts → Composant `Note`
+- Tables → Composant stylisé
+- Citations
+- Équations LaTeX (inline et bloc)
+
+### ⚠️ Conversion manuelle requise
+- Bases de données Notion → Créer en MDX
+- Toggles → Utiliser `Accordion`
+- Embeds complexes → Utiliser `HtmlEmbed`
+- Graphiques → Utiliser `Trackio` ou d3.js
+
+## 🔧 Désactiver l'import Notion
+
+Pour revenir à l'édition manuelle du MDX :
+
+1. HF Spaces → Settings → Repository secrets
+2. Changez `ENABLE_NOTION_IMPORT` à `false`
+3. Ou supprimez les variables d'env
+
+Le site continuera de fonctionner avec le dernier contenu importé.
+
+## 🆘 Dépannage
+
+### Erreur "❌ NOTION_TOKEN not found"
+→ Vérifiez que vous avez bien créé la variable `NOTION_TOKEN` dans les secrets HF
+
+### Erreur "❌ Could not find Notion page"
+→ Vérifiez que vous avez bien partagé la page avec votre intégration Notion
+
+### L'import ne se lance pas au build
+→ Vérifiez que `ENABLE_NOTION_IMPORT=true` (sans guillemets)
+
+### Le build échoue pendant l'import
+→ Regardez les logs du build dans HF Spaces pour voir l'erreur exacte
+
+## 💡 Conseils
+
+1. **Testez en local d'abord** : Évitez les surprises en prod
+2. **Structure claire** : Utilisez bien les titres h1, h2, h3 dans Notion
+3. **Images optimisées** : Les images sont téléchargées et intégrées
+4. **Commits Git** : Pour un vrai versioning, committez aussi les MDX générés
+5. **Brouillons** : Gardez des pages privées pour vos brouillons Notion
+
+## 📚 Pour aller plus loin
+
+- [Documentation Notion API](https://developers.notion.com/)
+- [Documentation HuggingFace Spaces](https://huggingface.co/docs/hub/spaces)
+- [README du Notion Importer](./app/scripts/notion-importer/README.md)
+

app/scripts/notion-importer/README.md

@@ -0,0 +1,291 @@
+# Notion Importer
+
+Complete Notion to MDX (Markdown + JSX) importer optimized for Astro with advanced media handling, interactive components, and seamless integration.
+
+## 🚀 Quick Start
+
+### Method 1: Using NOTION_PAGE_ID (Recommended)
+
+```bash
+# Install dependencies
+npm install
+
+# Setup environment variables
+cp env.example .env
+# Edit .env with your Notion token and page ID
+
+# Complete Notion → MDX conversion (fetches title/slug automatically)
+NOTION_TOKEN=secret_xxx NOTION_PAGE_ID=abc123 node index.mjs
+
+# Or use .env file
+node index.mjs
+```
+
+### Method 2: Using pages.json (Legacy)
+
+```bash
+# Install dependencies
+npm install
+
+# Setup environment variables
+cp env.example .env
+# Edit .env with your Notion token
+
+# Configure pages in input/pages.json
+# {
+#   "pages": [
+#     {
+#       "id": "your-page-id",
+#       "title": "Title",
+#       "slug": "slug"
+#     }
+#   ]
+# }
+
+# Complete Notion → MDX conversion
+node index.mjs
+
+# For step-by-step debugging
+node notion-converter.mjs    # Notion → Markdown
+node mdx-converter.mjs       # Markdown → MDX
+```
+
+## 📁 Structure
+
+```
+notion-importer/
+├── index.mjs                    # Complete Notion → MDX pipeline
+├── notion-converter.mjs         # Notion → Markdown with notion-to-md v4
+├── mdx-converter.mjs           # Markdown → MDX with Astro components
+├── post-processor.mjs          # Markdown post-processing
+├── package.json                # Dependencies and scripts
+├── env.example                 # Environment variables template
+├── input/                      # Configuration
+│   └── pages.json             # Notion pages to convert
+└── output/                     # Results
+    ├── *.md                   # Intermediate Markdown
+    ├── *.mdx                  # Final MDX for Astro
+    └── media/                 # Downloaded media files
+```
+
+## ✨ Key Features
+
+### 🎯 **Advanced Media Handling**
+- **Local download**: Automatic download of all Notion media (images, files, PDFs)
+- **Path transformation**: Smart path conversion for web accessibility
+- **Figure components**: Automatic conversion to Astro `Figure` components with zoom/download
+- **Media organization**: Structured media storage by page ID
+
+### 🧮 **Interactive Components**
+- **Callouts → Notes**: Notion callouts converted to Astro `Note` components
+- **Enhanced tables**: Tables wrapped in styled containers
+- **Code blocks**: Enhanced with copy functionality
+- **Automatic imports**: Smart component and image import generation
+
+### 🎨 **Smart Formatting**  
+- **Link fixing**: Notion internal links converted to relative links
+- **Artifact cleanup**: Removal of Notion-specific formatting artifacts
+- **Frontmatter generation**: Automatic YAML frontmatter from Notion properties
+- **Astro compatibility**: Full compatibility with Astro MDX processing
+
+### 🔧 **Robust Pipeline**
+- **Notion preprocessing**: Advanced page configuration and media strategy
+- **Post-processing**: Markdown cleanup and optimization
+- **MDX conversion**: Final transformation with Astro components
+- **Auto-copy**: Automatic copying to Astro content directory
+
+## 📊 Example Workflow
+
+```bash
+# 1. Configure your Notion pages
+# Edit input/pages.json with your page IDs
+
+# 2. Complete automatic conversion
+NOTION_TOKEN=your_token node index.mjs --clean
+
+# 3. Generated results
+ls output/
+# → getting-started.md (Intermediate Markdown)  
+# → getting-started.mdx (Final MDX for Astro)
+# → media/ (downloaded images and files)
+```
+
+### 📋 Conversion Result
+
+The pipeline generates MDX files optimized for Astro with:
+
+```mdx
+---
+title: "Getting Started with Notion"
+published: "2024-01-15"
+tableOfContentsAutoCollapse: true
+---
+
+import Figure from '../components/Figure.astro';
+import Note from '../components/Note.astro';
+import gettingStartedImage from './media/getting-started/image1.png';
+
+## Introduction
+
+Here is some content with a callout:
+
+<Note type="info" title="Important">
+This is a converted Notion callout.
+</Note>
+
+And an image:
+
+<Figure
+  src={gettingStartedImage}
+  alt="Getting started screenshot"
+  zoomable
+  downloadable
+  layout="fixed"
+/>
+```
+
+## ⚙️ Required Astro Configuration
+
+To use the generated MDX files, ensure your Astro project has the required components:
+
+```astro
+// src/components/Figure.astro
+---
+export interface Props {
+  src: any;
+  alt?: string;
+  caption?: string;
+  zoomable?: boolean;
+  downloadable?: boolean;
+  layout?: string;
+  id?: string;
+}
+
+const { src, alt, caption, zoomable, downloadable, layout, id } = Astro.props;
+---
+
+<figure {id} class="figure">
+  <img src={src} alt={alt} />
+  {caption && <figcaption>{caption}</figcaption>}
+</figure>
+```
+
+## 🛠️ Prerequisites
+
+- **Node.js** with ESM support
+- **Notion Integration**: Set up an integration in your Notion workspace
+- **Notion Token**: Copy the "Internal Integration Token"
+- **Shared Pages**: Share the specific Notion page(s) with your integration
+- **Astro** to use the generated MDX
+
+## 🎯 Technical Architecture
+
+### 4-Stage Pipeline
+
+1. **Notion Preprocessing** (`notion-converter.mjs`)
+   - Configuration loading from `pages.json`
+   - Notion API client initialization
+   - Media download strategy configuration
+
+2. **Notion-to-Markdown** (notion-to-md v4)
+   - Page conversion with `NotionConverter`
+   - Media downloading with `downloadMediaTo()`
+   - File export with `DefaultExporter`
+
+3. **Markdown Post-processing** (`post-processor.mjs`)
+   - Notion artifact cleanup
+   - Link fixing and optimization
+   - Table and code block enhancement
+
+4. **MDX Conversion** (`mdx-converter.mjs`)
+   - Component transformation (Figure, Note)
+   - Automatic import generation
+   - Frontmatter enhancement
+   - Astro compatibility optimization
+
+## 📊 Configuration Options
+
+### Pages Configuration (`input/pages.json`)
+
+```json
+{
+  "pages": [
+    {
+      "id": "your-notion-page-id",
+      "title": "Page Title",
+      "slug": "page-slug"
+    }
+  ]
+}
+```
+
+### Environment Variables
+
+Copy `env.example` to `.env` and configure:
+
+```bash
+cp env.example .env
+# Edit .env with your actual Notion token
+```
+
+Required variables:
+```bash
+NOTION_TOKEN=secret_your_notion_integration_token_here
+```
+
+### Command Line Options
+
+```bash
+# Full workflow
+node index.mjs --clean --token=your_token
+
+# Notion to Markdown only
+node index.mjs --notion-only
+
+# Markdown to MDX only  
+node index.mjs --mdx-only
+
+# Custom paths
+node index.mjs --input=my-pages.json --output=converted/
+```
+
+## 📊 Conversion Statistics
+
+For a typical Notion page:
+- **Media files** automatically downloaded and organized
+- **Callouts** converted to interactive Note components
+- **Images** transformed to Figure components with zoom/download
+- **Tables** enhanced with proper styling containers
+- **Code blocks** enhanced with copy functionality
+- **Links** fixed for proper internal navigation
+
+## ✅ Project Status
+
+### 🎉 **Complete Features**
+- ✅ **Notion → MDX Pipeline**: Full end-to-end functional conversion
+- ✅ **Media Management**: Automatic download and path transformation
+- ✅ **Component Integration**: Seamless Astro component integration
+- ✅ **Smart Formatting**: Intelligent cleanup and optimization
+- ✅ **Robustness**: Error handling and graceful degradation
+- ✅ **Flexibility**: Modular pipeline with step-by-step options
+
+### 🚀 **Production Ready**
+The toolkit is now **100% operational** for converting Notion pages to MDX/Astro with all advanced features (media handling, component integration, smart formatting).
+
+## 🔗 Integration with notion-to-md v4
+
+This toolkit leverages the powerful [notion-to-md v4](https://notionconvert.com/docs/v4/guides/) library with:
+
+- **Advanced Media Strategies**: Download, upload, and direct media handling
+- **Custom Renderers**: Block transformers and annotation transformers  
+- **Exporter Plugins**: File, buffer, and stdout output options
+- **Database Support**: Full database property and frontmatter transformation
+- **Page References**: Smart internal link handling
+
+## 📚 Additional Resources
+
+- [notion-to-md v4 Documentation](https://notionconvert.com/docs/v4/guides/)
+- [Notion API Documentation](https://developers.notion.com/)
+- [Astro MDX Documentation](https://docs.astro.build/en/guides/integrations-guide/mdx/)
+- [Media Handling Strategies](https://notionconvert.com/blog/mastering-media-handling-in-notion-to-md-v4-download-upload-and-direct-strategies/)
+- [Frontmatter Transformation](https://notionconvert.com/blog/how-to-convert-notion-properties-to-frontmatter-with-notion-to-md-v4/)

app/scripts/notion-importer/env.example

@@ -0,0 +1,2 @@
+NOTION_TOKEN=ntn_xxx
+NOTION_PAGE_ID=xxx

app/scripts/notion-importer/index.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+import { config } from 'dotenv';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
+import { convertNotionToMarkdown } from './notion-converter.mjs';
+import { convertToMdx } from './mdx-converter.mjs';
+import { Client } from '@notionhq/client';
+
+// Load environment variables from .env file
+config();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Default configuration
+const DEFAULT_INPUT = join(__dirname, 'input', 'pages.json');
+const DEFAULT_OUTPUT = join(__dirname, 'output');
+const ASTRO_CONTENT_PATH = join(__dirname, '..', '..', 'src', 'content', 'article.mdx');
+const ASTRO_ASSETS_PATH = join(__dirname, '..', '..', 'src', 'content', 'assets', 'image');
+const ASTRO_BIB_PATH = join(__dirname, '..', '..', 'src', 'content', 'bibliography.bib');
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        input: DEFAULT_INPUT,
+        output: DEFAULT_OUTPUT,
+        clean: false,
+        notionOnly: false,
+        mdxOnly: false,
+        token: process.env.NOTION_TOKEN,
+        pageId: process.env.NOTION_PAGE_ID
+    };
+
+    for (const arg of args) {
+        if (arg.startsWith('--input=')) {
+            config.input = arg.split('=')[1];
+        } else if (arg.startsWith('--output=')) {
+            config.output = arg.split('=')[1];
+        } else if (arg.startsWith('--token=')) {
+            config.token = arg.split('=')[1];
+        } else if (arg.startsWith('--page-id=')) {
+            config.pageId = arg.split('=')[1];
+        } else if (arg === '--clean') {
+            config.clean = true;
+        } else if (arg === '--notion-only') {
+            config.notionOnly = true;
+        } else if (arg === '--mdx-only') {
+            config.mdxOnly = true;
+        }
+    }
+
+    return config;
+}
+
+function showHelp() {
+    console.log(`
+🚀 Notion to MDX Toolkit
+
+Usage:
+  node index.mjs [options]
+
+Options:
+  --input=PATH      Input pages configuration file (default: input/pages.json)
+  --output=PATH     Output directory (default: output/)
+  --token=TOKEN     Notion API token (or set NOTION_TOKEN env var)
+  --clean           Clean output directory before processing
+  --notion-only     Only convert Notion to Markdown (skip MDX conversion)
+  --mdx-only        Only convert existing Markdown to MDX
+  --help, -h        Show this help
+
+Environment Variables:
+  NOTION_TOKEN      Your Notion integration token
+
+Examples:
+  # Full conversion workflow
+  NOTION_TOKEN=your_token node index.mjs --clean
+
+  # Only convert Notion pages to Markdown
+  node index.mjs --notion-only --token=your_token
+
+  # Only convert existing Markdown to MDX
+  node index.mjs --mdx-only
+
+  # Custom paths
+  node index.mjs --input=my-pages.json --output=converted/ --token=your_token
+
+Configuration File Format (pages.json):
+{
+  "pages": [
+    {
+      "id": "your-notion-page-id",
+      "title": "Page Title",
+      "slug": "page-slug"
+    }
+  ]
+}
+
+Workflow:
+  1. Notion → Markdown (with media download)
+  2. Markdown → MDX (with Astro components)
+  3. Copy to Astro content directory
+`);
+}
+
+function ensureDirectory(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+
+async function cleanDirectory(dir) {
+    if (existsSync(dir)) {
+        const { execSync } = await import('child_process');
+        execSync(`rm -rf "${dir}"/*`, { stdio: 'inherit' });
+    }
+}
+
+function readPagesConfig(inputFile) {
+    try {
+        const content = readFileSync(inputFile, 'utf8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error(`❌ Error reading pages config: ${error.message}`);
+        return { pages: [] };
+    }
+}
+
+/**
+ * Create a temporary pages.json from NOTION_PAGE_ID environment variable
+ * Extracts title and generates slug from the Notion page
+ */
+async function createPagesConfigFromEnv(pageId, token, outputPath) {
+    try {
+        console.log('🔍 Fetching page info from Notion API...');
+        const notion = new Client({ auth: token });
+        const page = await notion.pages.retrieve({ page_id: pageId });
+
+        // Extract title
+        let title = 'Article';
+        if (page.properties.title && page.properties.title.title && page.properties.title.title.length > 0) {
+            title = page.properties.title.title[0].plain_text;
+        } else if (page.properties.Name && page.properties.Name.title && page.properties.Name.title.length > 0) {
+            title = page.properties.Name.title[0].plain_text;
+        }
+
+        // Generate slug from title
+        const slug = title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .trim();
+
+        console.log(`    ✅ Found page: "${title}" (slug: ${slug})`);
+
+        // Create pages config
+        const pagesConfig = {
+            pages: [{
+                id: pageId,
+                title: title,
+                slug: slug
+            }]
+        };
+
+        // Write to temporary file
+        writeFileSync(outputPath, JSON.stringify(pagesConfig, null, 4));
+        console.log(`    ✅ Created temporary pages config`);
+
+        return pagesConfig;
+    } catch (error) {
+        console.error(`❌ Error fetching page from Notion: ${error.message}`);
+        throw error;
+    }
+}
+
+function copyToAstroContent(outputDir) {
+    console.log('📋 Copying MDX files to Astro content directory...');
+
+    try {
+        // Ensure Astro directories exist
+        mkdirSync(dirname(ASTRO_CONTENT_PATH), { recursive: true });
+        mkdirSync(ASTRO_ASSETS_PATH, { recursive: true });
+
+        // Copy MDX file
+        const files = readdirSync(outputDir);
+        const mdxFiles = files.filter(file => file.endsWith('.mdx'));
+        if (mdxFiles.length > 0) {
+            const mdxFile = join(outputDir, mdxFiles[0]); // Take the first MDX file
+            copyFileSync(mdxFile, ASTRO_CONTENT_PATH);
+            console.log(`    ✅ Copied MDX to ${ASTRO_CONTENT_PATH}`);
+        }
+
+        // Copy images
+        const mediaDir = join(outputDir, 'media');
+        if (existsSync(mediaDir)) {
+            const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.svg'];
+            let imageCount = 0;
+
+            function copyImagesRecursively(dir) {
+                const files = readdirSync(dir);
+                for (const file of files) {
+                    const filePath = join(dir, file);
+                    const stat = statSync(filePath);
+
+                    if (stat.isDirectory()) {
+                        copyImagesRecursively(filePath);
+                    } else if (imageExtensions.some(ext => file.toLowerCase().endsWith(ext))) {
+                        const filename = basename(filePath);
+                        const destPath = join(ASTRO_ASSETS_PATH, filename);
+                        copyFileSync(filePath, destPath);
+                        imageCount++;
+                    }
+                }
+            }
+
+            copyImagesRecursively(mediaDir);
+            console.log(`    ✅ Copied ${imageCount} image(s) to ${ASTRO_ASSETS_PATH}`);
+
+            // Update image paths in MDX file
+            const mdxContent = readFileSync(ASTRO_CONTENT_PATH, 'utf8');
+            let updatedContent = mdxContent.replace(/\.\/media\//g, './assets/image/');
+            // Remove the subdirectory from image paths since we copy images directly to assets/image/
+            updatedContent = updatedContent.replace(/\.\/assets\/image\/[^\/]+\//g, './assets/image/');
+            writeFileSync(ASTRO_CONTENT_PATH, updatedContent);
+            console.log(`    ✅ Updated image paths in MDX file`);
+        }
+
+        // Create empty bibliography.bib
+        writeFileSync(ASTRO_BIB_PATH, '');
+        console.log(`    ✅ Created empty bibliography at ${ASTRO_BIB_PATH}`);
+
+    } catch (error) {
+        console.warn(`    ⚠️  Failed to copy to Astro: ${error.message}`);
+    }
+}
+
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+        process.exit(0);
+    }
+
+    const config = parseArgs();
+
+    console.log('🚀 Notion to MDX Toolkit');
+    console.log('========================');
+
+    try {
+        // Prepare input config file
+        let inputConfigFile = config.input;
+        let pageIdFromEnv = null;
+
+        // If NOTION_PAGE_ID is provided via env var, create temporary pages.json
+        if (config.pageId && config.token) {
+            console.log('✨ Using NOTION_PAGE_ID from environment variable');
+            const tempConfigPath = join(config.output, '.temp-pages.json');
+            ensureDirectory(config.output);
+            await createPagesConfigFromEnv(config.pageId, config.token, tempConfigPath);
+            inputConfigFile = tempConfigPath;
+            pageIdFromEnv = config.pageId;
+        } else if (!existsSync(config.input)) {
+            console.error(`❌ No NOTION_PAGE_ID environment variable and no pages.json found at: ${config.input}`);
+            console.log('💡 Either set NOTION_PAGE_ID env var or create input/pages.json');
+            process.exit(1);
+        }
+
+        if (config.clean) {
+            console.log('🧹 Cleaning output directory...');
+            await cleanDirectory(config.output);
+        }
+
+        if (config.mdxOnly) {
+            // Only convert existing Markdown to MDX
+            console.log('📝 MDX conversion only mode');
+            await convertToMdx(config.output, config.output);
+            copyToAstroContent(config.output);
+
+        } else if (config.notionOnly) {
+            // Only convert Notion to Markdown
+            console.log('📄 Notion conversion only mode');
+            await convertNotionToMarkdown(inputConfigFile, config.output, config.token);
+
+        } else {
+            // Full workflow
+            console.log('🔄 Full conversion workflow');
+
+            // Step 1: Convert Notion to Markdown
+            console.log('\n📄 Step 1: Converting Notion pages to Markdown...');
+            await convertNotionToMarkdown(inputConfigFile, config.output, config.token);
+
+            // Step 2: Convert Markdown to MDX with Notion metadata
+            console.log('\n📝 Step 2: Converting Markdown to MDX...');
+            const pagesConfig = readPagesConfig(inputConfigFile);
+            const firstPage = pagesConfig.pages && pagesConfig.pages.length > 0 ? pagesConfig.pages[0] : null;
+            const pageId = pageIdFromEnv || (firstPage ? firstPage.id : null);
+            await convertToMdx(config.output, config.output, pageId, config.token);
+
+            // Step 3: Copy to Astro content directory
+            console.log('\n📋 Step 3: Copying to Astro content directory...');
+            copyToAstroContent(config.output);
+        }
+
+        console.log('\n🎉 Conversion completed successfully!');
+
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        process.exit(1);
+    }
+}
+
+// Export functions for use as module
+export { convertNotionToMarkdown, convertToMdx };
+
+// Run CLI if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}