@bulkpublishing/mcp-server 1.0.0

package/dist/tools/csv.js

@@ -0,0 +1,673 @@
+/**
+ * BPAI MCP Server — CSV Import / Export Tools
+ *
+ * MCP tool handlers for:
+ *  - import_csv:      Read a local CSV and auto-detect columns
+ *  - export_csv:      Write articles to a CSV file
+ *  - export_markdown: Write articles as individual .md files
+ *  - export_json:     Write articles as structured JSON
+ *  - export_bulk:     Combined multi-format export with filtering
+ *
+ * Security:
+ *  - All operations run on the user's local machine (filesystem only)
+ *  - No database or remote calls; articles are provided inline by the MCP client
+ *  - Auth check on every tool call via getUserContext()
+ */
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getUserContext } from '../auth/context.js';
+// ============================================
+// Column Auto-Detection
+// ============================================
+/** Canonical field → list of recognized CSV header variations (all lowercase) */
+const COLUMN_ALIASES = {
+    keyword: ['keyword', 'target_keyword', 'focus_keyword', 'kw', 'primary_keyword', 'search_term', 'query', 'main_keyword', 'keyphrase', 'focus_keyphrase'],
+    title: ['title', 'post_title', 'h1', 'headline', 'article_title', 'page_title', 'heading'],
+    meta_description: ['meta', 'meta_description', 'meta_desc', 'description', 'seo_description', 'metadescription'],
+    slug: ['slug', 'url_slug', 'permalink', 'url', 'path', 'handle', 'url_handle'],
+    category: ['category', 'cat', 'section', 'topic', 'group', 'categories'],
+    tone: ['tone', 'voice', 'style', 'writing_style', 'writing_tone'],
+    word_count: ['word_count', 'length', 'target_length', 'words', 'target_words', 'wordcount'],
+    instructions: ['instructions', 'notes', 'prompt_override', 'custom_prompt', 'additional_context', 'context', 'brief'],
+    tags: ['tags', 'keywords', 'labels', 'secondary_keywords'],
+    content: ['content', 'body', 'article_content', 'body_html', 'html', 'markdown', 'article_body', 'post_content'],
+    status: ['status', 'state', 'publish_status'],
+    author: ['author', 'author_name', 'writer'],
+    date: ['date', 'publish_date', 'created_at', 'created', 'published_date'],
+};
+function detectColumns(headers) {
+    const mapping = {};
+    const normalised = headers.map(h => h.trim().toLowerCase().replace(/[\s-]+/g, '_'));
+    for (const [field, aliases] of Object.entries(COLUMN_ALIASES)) {
+        for (let i = 0; i < normalised.length; i++) {
+            if (aliases.includes(normalised[i])) {
+                mapping[field] = headers[i].trim();
+                break;
+            }
+        }
+    }
+    return mapping;
+}
+// ============================================
+// CSV Parsing Helpers
+// ============================================
+function parseCSVLine(line, delimiter) {
+    const fields = [];
+    let current = '';
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (inQuotes) {
+            if (char === '"') {
+                if (i + 1 < line.length && line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        else {
+            if (char === '"') {
+                inQuotes = true;
+            }
+            else if (char === delimiter) {
+                fields.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+function parseCSV(raw, delimiter, skipRows) {
+    const lines = raw.split(/\r?\n/).filter(l => l.trim().length > 0);
+    const dataLines = lines.slice(skipRows);
+    if (dataLines.length === 0)
+        return { headers: [], rows: [] };
+    const headers = parseCSVLine(dataLines[0], delimiter);
+    const rows = [];
+    for (let i = 1; i < dataLines.length; i++) {
+        const values = parseCSVLine(dataLines[i], delimiter);
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            row[headers[j].trim()] = (values[j] || '').trim();
+        }
+        rows.push(row);
+    }
+    return { headers, rows };
+}
+// ============================================
+// CSV Writing Helpers
+// ============================================
+function escapeCSVField(value) {
+    if (value.includes('"') || value.includes(',') || value.includes('\n') || value.includes('\r')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+// ============================================
+// Shared Article Schema (for export tools)
+// ============================================
+const articleSchema = z.object({
+    title: z.string().describe('Article title'),
+    slug: z.string().optional().describe('URL slug'),
+    keyword: z.string().optional().describe('Target keyword'),
+    meta_description: z.string().optional().describe('Meta description'),
+    content: z.string().describe('Article content (Markdown or HTML)'),
+    word_count: z.number().optional().describe('Word count'),
+    model: z.string().optional().describe('AI model used'),
+    status: z.string().optional().default('draft').describe('draft, published, etc.'),
+    category: z.string().optional().describe('Category name'),
+    tags: z.string().optional().describe('Comma-separated tags'),
+    author: z.string().optional().describe('Author name'),
+    created_at: z.string().optional().describe('Creation date ISO string'),
+    research_citations: z.array(z.string()).optional().describe('Source URLs from research'),
+    faq_schema: z.string().optional().describe('FAQ structured data'),
+});
+// ============================================
+// Filtering Helper
+// ============================================
+function filterArticles(articles, filters) {
+    let result = [...articles];
+    if (filters.filter_status && filters.filter_status !== 'all') {
+        result = result.filter(a => (a.status || 'draft') === filters.filter_status);
+    }
+    if (filters.filter_model) {
+        result = result.filter(a => a.model && a.model.toLowerCase().includes(filters.filter_model.toLowerCase()));
+    }
+    if (filters.filter_date_from) {
+        const from = new Date(filters.filter_date_from).getTime();
+        result = result.filter(a => a.created_at && new Date(a.created_at).getTime() >= from);
+    }
+    if (filters.filter_date_to) {
+        const to = new Date(filters.filter_date_to).getTime();
+        result = result.filter(a => a.created_at && new Date(a.created_at).getTime() <= to);
+    }
+    if (filters.filter_min_words) {
+        result = result.filter(a => (a.word_count || 0) >= filters.filter_min_words);
+    }
+    return result;
+}
+// ============================================
+// Export Generators
+// ============================================
+function generateCSVContent(articles, columns, includeHtml) {
+    const defaultCols = ['title', 'slug', 'keyword', 'meta_description', 'word_count', 'model', 'status', 'category', 'tags', 'content'];
+    const activeCols = columns && columns.length > 0 ? columns : defaultCols;
+    const headerRow = activeCols.map(c => escapeCSVField(c)).join(',');
+    const dataRows = articles.map(article => {
+        return activeCols.map(col => {
+            let val = '';
+            switch (col) {
+                case 'title':
+                    val = article.title || '';
+                    break;
+                case 'slug':
+                    val = article.slug || '';
+                    break;
+                case 'keyword':
+                    val = article.keyword || '';
+                    break;
+                case 'meta_description':
+                    val = article.meta_description || '';
+                    break;
+                case 'content':
+                    val = article.content || '';
+                    break;
+                case 'content_html':
+                    val = includeHtml ? (article.content || '') : '';
+                    break;
+                case 'word_count':
+                    val = String(article.word_count || '');
+                    break;
+                case 'model':
+                    val = article.model || '';
+                    break;
+                case 'status':
+                    val = article.status || 'draft';
+                    break;
+                case 'category':
+                    val = article.category || '';
+                    break;
+                case 'tags':
+                    val = article.tags || '';
+                    break;
+                case 'author':
+                    val = article.author || '';
+                    break;
+                case 'created_at':
+                    val = article.created_at || '';
+                    break;
+                case 'citations':
+                    val = (article.research_citations || []).join(' | ');
+                    break;
+                case 'faq_schema':
+                    val = article.faq_schema || '';
+                    break;
+                default:
+                    val = article[col] || '';
+                    break;
+            }
+            return escapeCSVField(val);
+        }).join(',');
+    });
+    return [headerRow, ...dataRows].join('\n');
+}
+function generateMarkdownFile(article, projectName) {
+    const frontmatter = {
+        title: article.title,
+    };
+    if (article.slug)
+        frontmatter.slug = article.slug;
+    if (article.keyword)
+        frontmatter.keyword = article.keyword;
+    if (article.meta_description)
+        frontmatter.meta_description = article.meta_description;
+    if (article.created_at)
+        frontmatter.date = article.created_at.split('T')[0];
+    if (article.author)
+        frontmatter.author = article.author;
+    if (projectName)
+        frontmatter.project = projectName;
+    if (article.word_count)
+        frontmatter.word_count = article.word_count;
+    if (article.model)
+        frontmatter.model = article.model;
+    if (article.status)
+        frontmatter.status = article.status;
+    if (article.category)
+        frontmatter.category = article.category;
+    if (article.tags) {
+        frontmatter.tags = article.tags.split(',').map(t => t.trim()).filter(Boolean);
+    }
+    const yamlLines = Object.entries(frontmatter).map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return `${key}:\n${value.map(v => `  - ${v}`).join('\n')}`;
+        }
+        if (typeof value === 'number')
+            return `${key}: ${value}`;
+        return `${key}: "${String(value).replace(/"/g, '\\"')}"`;
+    });
+    return `---\n${yamlLines.join('\n')}\n---\n\n${article.content}`;
+}
+function generateJSONContent(articles, projectName, pretty) {
+    const output = {
+        exported_at: new Date().toISOString(),
+        project: projectName || 'Default',
+        total_articles: articles.length,
+        articles: articles.map((a, idx) => ({
+            id: `art_${String(idx + 1).padStart(3, '0')}`,
+            title: a.title,
+            slug: a.slug || '',
+            keyword: a.keyword || '',
+            meta_description: a.meta_description || '',
+            content_markdown: a.content,
+            word_count: a.word_count || 0,
+            model: a.model || '',
+            status: a.status || 'draft',
+            category: a.category || '',
+            tags: a.tags ? a.tags.split(',').map(t => t.trim()) : [],
+            created_at: a.created_at || '',
+            research_citations: a.research_citations || [],
+        })),
+    };
+    return JSON.stringify(output, null, pretty !== false ? 2 : 0);
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 80);
+}
+// ============================================
+// TOOL REGISTRATION
+// ============================================
+export function registerCSVTools(server) {
+    // =====================
+    // import_csv
+    // =====================
+    server.tool('import_csv', 'Read a local CSV file and prepare it for batch generation. Auto-detects common column headers (keyword, title, slug, meta_description, etc.) or accepts manual mapping. Use preview_only to inspect the file before committing.', {
+        file_path: z.string().describe('Absolute path to the CSV file'),
+        column_map: z.record(z.string(), z.string()).optional().describe('Manual column mapping: { canonical_field: "Your CSV Header" }'),
+        delimiter: z.string().default(',').describe('CSV delimiter character (, ; or \\t)'),
+        encoding: z.string().default('utf-8').describe('File encoding'),
+        skip_rows: z.number().default(0).describe('Number of header/info rows to skip before the column headers'),
+        max_rows: z.number().optional().describe('Maximum number of rows to import'),
+        preview_only: z.boolean().default(false).describe('Preview first 5 rows without full import'),
+    }, async (args) => {
+        const ctx = getUserContext();
+        if (!ctx.authenticated) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Not authenticated. Check your BPAI_API_KEY.' }, null, 2) }] };
+        }
+        try {
+            // Read file
+            const raw = await fs.readFile(args.file_path, { encoding: args.encoding });
+            const { headers, rows } = parseCSV(raw, args.delimiter, args.skip_rows);
+            if (headers.length === 0) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'No columns found in file. Check the delimiter and skip_rows settings.' }, null, 2) }] };
+            }
+            // Detect columns
+            const autoDetected = detectColumns(headers);
+            const columnMapping = args.column_map
+                ? { ...autoDetected, ...args.column_map }
+                : autoDetected;
+            // Map rows to canonical fields
+            const invertedMap = {};
+            for (const [canonical, csvHeader] of Object.entries(columnMapping)) {
+                invertedMap[csvHeader] = canonical;
+            }
+            const mappedRows = rows.map(row => {
+                const mapped = {};
+                for (const [header, value] of Object.entries(row)) {
+                    const canonical = invertedMap[header];
+                    if (canonical) {
+                        mapped[canonical] = value;
+                    }
+                    else {
+                        mapped[header] = value;
+                    }
+                }
+                return mapped;
+            });
+            // Apply limits
+            const limitedRows = args.max_rows ? mappedRows.slice(0, args.max_rows) : mappedRows;
+            const previewRows = args.preview_only ? limitedRows.slice(0, 5) : limitedRows;
+            // Column detection summary
+            const detectionSummary = {};
+            for (const [field, header] of Object.entries(columnMapping)) {
+                const isManual = args.column_map && field in args.column_map;
+                detectionSummary[field] = `${header} (${isManual ? 'manual override' : 'auto-detected'})`;
+            }
+            // Identify unmapped columns
+            const mappedHeaders = new Set(Object.values(columnMapping));
+            const unmapped = headers.filter(h => !mappedHeaders.has(h.trim()));
+            const result = {
+                status: 'success',
+                file: args.file_path,
+                rows_found: rows.length,
+                rows_imported: args.preview_only ? 0 : limitedRows.length,
+                columns_detected: detectionSummary,
+                unmapped_columns: unmapped.length > 0 ? unmapped : undefined,
+                preview: previewRows.slice(0, 5),
+                ready_for_generation: !!columnMapping.keyword,
+            };
+            if (args.preview_only) {
+                result.note = 'Preview mode — no rows imported. Remove preview_only to import.';
+            }
+            if (!args.preview_only) {
+                result.rows = limitedRows;
+            }
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: `File not found: ${args.file_path}` }, null, 2) }] };
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ error: `Failed to read CSV: ${err.message}` }, null, 2) }] };
+        }
+    });
+    // =====================
+    // export_csv
+    // =====================
+    server.tool('export_csv', 'Export articles as a CSV file. Provide the articles array from a previous generation or pass them directly. Supports column selection and status filtering.', {
+        output_path: z.string().describe('Absolute path where the CSV will be saved'),
+        articles: z.array(articleSchema).describe('Array of articles to export'),
+        columns: z.array(z.string()).optional().describe('Which columns to include (defaults to all standard columns)'),
+        filter_status: z.string().optional().describe('Filter by status: draft, published, or all'),
+        include_html: z.boolean().default(false).describe('Include HTML content column'),
+        include_markdown: z.boolean().default(true).describe('Include Markdown content column'),
+    }, async (args) => {
+        const ctx = getUserContext();
+        if (!ctx.authenticated) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Not authenticated. Check your BPAI_API_KEY.' }, null, 2) }] };
+        }
+        try {
+            const filtered = filterArticles(args.articles, { filter_status: args.filter_status });
+            if (filtered.length === 0) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'No articles match the given filters.' }, null, 2) }] };
+            }
+            const csvContent = generateCSVContent(filtered, args.columns, args.include_html);
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(args.output_path), { recursive: true });
+            await fs.writeFile(args.output_path, csvContent, 'utf-8');
+            return {
+                content: [{
+                        type: 'text', text: JSON.stringify({
+                            status: 'success',
+                            output_file: args.output_path,
+                            articles_exported: filtered.length,
+                            file_size: `${(Buffer.byteLength(csvContent) / 1024).toFixed(1)} KB`,
+                        }, null, 2)
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: `CSV export failed: ${err.message}` }, null, 2) }] };
+        }
+    });
+    // =====================
+    // export_markdown
+    // =====================
+    server.tool('export_markdown', 'Export articles as individual Markdown files with YAML frontmatter. Each article becomes a separate .md file. Supports flat or nested folder structure.', {
+        output_dir: z.string().describe('Directory to write Markdown files to'),
+        articles: z.array(articleSchema).describe('Array of articles to export'),
+        project_name: z.string().optional().describe('Project name for frontmatter and nested folder structure'),
+        structure: z.enum(['flat', 'nested']).default('flat').describe('flat = all files in one folder, nested = grouped in project subfolder'),
+        filename_from: z.enum(['slug', 'title', 'keyword']).default('slug').describe('Which field to use for filenames'),
+        frontmatter: z.array(z.string()).optional().describe('Which fields to include in frontmatter (defaults to all)'),
+        filter_status: z.string().optional().describe('Filter by status: draft, published, or all'),
+    }, async (args) => {
+        const ctx = getUserContext();
+        if (!ctx.authenticated) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Not authenticated. Check your BPAI_API_KEY.' }, null, 2) }] };
+        }
+        try {
+            const filtered = filterArticles(args.articles, { filter_status: args.filter_status });
+            if (filtered.length === 0) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'No articles match the given filters.' }, null, 2) }] };
+            }
+            // Determine output directory
+            const baseDir = args.structure === 'nested' && args.project_name
+                ? path.join(args.output_dir, slugify(args.project_name))
+                : args.output_dir;
+            await fs.mkdir(baseDir, { recursive: true });
+            const written = [];
+            for (const article of filtered) {
+                // Generate filename
+                let filename;
+                switch (args.filename_from) {
+                    case 'title':
+                        filename = slugify(article.title);
+                        break;
+                    case 'keyword':
+                        filename = slugify(article.keyword || article.title);
+                        break;
+                    default:
+                        filename = article.slug || slugify(article.title);
+                        break;
+                }
+                const filePath = path.join(baseDir, `${filename}.md`);
+                const mdContent = generateMarkdownFile(article, args.project_name);
+                await fs.writeFile(filePath, mdContent, 'utf-8');
+                written.push(filePath);
+            }
+            // Write manifest
+            const manifest = {
+                exported_at: new Date().toISOString(),
+                project: args.project_name || 'Default',
+                total_files: written.length,
+                files: written.map(f => path.basename(f)),
+            };
+            await fs.writeFile(path.join(args.output_dir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+            return {
+                content: [{
+                        type: 'text', text: JSON.stringify({
+                            status: 'success',
+                            output_directory: baseDir,
+                            files_written: written.length,
+                            manifest: path.join(args.output_dir, 'manifest.json'),
+                            files: written.map(f => path.basename(f)),
+                        }, null, 2)
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: `Markdown export failed: ${err.message}` }, null, 2) }] };
+        }
+    });
+    // =====================
+    // export_json
+    // =====================
+    server.tool('export_json', 'Export articles as structured JSON. Useful for custom integrations, static site generators, or API import workflows.', {
+        output_path: z.string().describe('File path for JSON output'),
+        articles: z.array(articleSchema).describe('Array of articles to export'),
+        project_name: z.string().optional().describe('Project name for the export metadata'),
+        pretty: z.boolean().default(true).describe('Pretty-print the JSON output'),
+        filter_status: z.string().optional().describe('Filter by status: draft, published, or all'),
+    }, async (args) => {
+        const ctx = getUserContext();
+        if (!ctx.authenticated) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Not authenticated. Check your BPAI_API_KEY.' }, null, 2) }] };
+        }
+        try {
+            const filtered = filterArticles(args.articles, { filter_status: args.filter_status });
+            if (filtered.length === 0) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: 'No articles match the given filters.' }, null, 2) }] };
+            }
+            const jsonContent = generateJSONContent(filtered, args.project_name, args.pretty);
+            await fs.mkdir(path.dirname(args.output_path), { recursive: true });
+            await fs.writeFile(args.output_path, jsonContent, 'utf-8');
+            return {
+                content: [{
+                        type: 'text', text: JSON.stringify({
+                            status: 'success',
+                            output_file: args.output_path,
+                            articles_exported: filtered.length,
+                            file_size: `${(Buffer.byteLength(jsonContent) / 1024).toFixed(1)} KB`,
+                        }, null, 2)
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: `JSON export failed: ${err.message}` }, null, 2) }] };
+        }
+    });
+    // =====================
+    // export_bulk
+    // =====================
+    server.tool('export_bulk', 'Combined multi-format export with advanced filtering. Supports CSV, Markdown, JSON, and HTML output formats. Includes filters for status, model, date range, and minimum word count.', {
+        format: z.enum(['csv', 'markdown', 'json', 'html']).describe('Output format: csv, markdown, json, or html'),
+        output_path: z.string().describe('Output file path (csv/json/html) or directory (markdown)'),
+        articles: z.array(articleSchema).describe('Array of articles to export'),
+        project_name: z.string().optional().describe('Project name for metadata and folder structure'),
+        structure: z.enum(['flat', 'nested']).default('flat').describe('Folder structure for markdown exports'),
+        filter_status: z.string().optional().describe('Filter: draft, published, or all'),
+        filter_model: z.string().optional().describe('Filter by model name (partial match)'),
+        filter_date_from: z.string().optional().describe('Filter: start date (YYYY-MM-DD)'),
+        filter_date_to: z.string().optional().describe('Filter: end date (YYYY-MM-DD)'),
+        filter_min_words: z.number().optional().describe('Filter: minimum word count'),
+        include_metadata: z.boolean().default(true).describe('Include frontmatter/headers in output'),
+        columns: z.array(z.string()).optional().describe('Columns to include (CSV only)'),
+    }, async (args) => {
+        const ctx = getUserContext();
+        if (!ctx.authenticated) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Not authenticated. Check your BPAI_API_KEY.' }, null, 2) }] };
+        }
+        try {
+            const filtered = filterArticles(args.articles, {
+                filter_status: args.filter_status,
+                filter_model: args.filter_model,
+                filter_date_from: args.filter_date_from,
+                filter_date_to: args.filter_date_to,
+                filter_min_words: args.filter_min_words,
+            });
+            if (filtered.length === 0) {
+                return {
+                    content: [{
+                            type: 'text', text: JSON.stringify({
+                                error: 'No articles match the given filters.',
+                                total_before_filter: args.articles.length,
+                                filters_applied: {
+                                    status: args.filter_status || 'all',
+                                    model: args.filter_model || 'any',
+                                    date_from: args.filter_date_from || 'none',
+                                    date_to: args.filter_date_to || 'none',
+                                    min_words: args.filter_min_words || 'none',
+                                },
+                            }, null, 2)
+                        }]
+                };
+            }
+            let outputInfo = {};
+            switch (args.format) {
+                case 'csv': {
+                    const csvContent = generateCSVContent(filtered, args.columns);
+                    await fs.mkdir(path.dirname(args.output_path), { recursive: true });
+                    await fs.writeFile(args.output_path, csvContent, 'utf-8');
+                    outputInfo = {
+                        output_file: args.output_path,
+                        file_size: `${(Buffer.byteLength(csvContent) / 1024).toFixed(1)} KB`,
+                    };
+                    break;
+                }
+                case 'json': {
+                    const jsonContent = generateJSONContent(filtered, args.project_name, true);
+                    await fs.mkdir(path.dirname(args.output_path), { recursive: true });
+                    await fs.writeFile(args.output_path, jsonContent, 'utf-8');
+                    outputInfo = {
+                        output_file: args.output_path,
+                        file_size: `${(Buffer.byteLength(jsonContent) / 1024).toFixed(1)} KB`,
+                    };
+                    break;
+                }
+                case 'markdown': {
+                    const baseDir = args.structure === 'nested' && args.project_name
+                        ? path.join(args.output_path, slugify(args.project_name))
+                        : args.output_path;
+                    await fs.mkdir(baseDir, { recursive: true });
+                    const written = [];
+                    for (const article of filtered) {
+                        const filename = article.slug || slugify(article.title);
+                        const filePath = path.join(baseDir, `${filename}.md`);
+                        const md = generateMarkdownFile(article, args.project_name);
+                        await fs.writeFile(filePath, md, 'utf-8');
+                        written.push(path.basename(filePath));
+                    }
+                    const manifest = {
+                        exported_at: new Date().toISOString(),
+                        project: args.project_name || 'Default',
+                        total_files: written.length,
+                        files: written,
+                    };
+                    await fs.writeFile(path.join(args.output_path, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+                    outputInfo = {
+                        output_directory: baseDir,
+                        files: written,
+                        manifest: path.join(args.output_path, 'manifest.json'),
+                    };
+                    break;
+                }
+                case 'html': {
+                    // Generate a single HTML file with all articles
+                    const htmlParts = filtered.map(a => {
+                        const meta = args.include_metadata
+                            ? `<div class="article-meta"><span>${a.keyword || ''}</span> | <span>${a.word_count || 0} words</span> | <span>${a.model || ''}</span></div>\n`
+                            : '';
+                        return `<article>\n<h1>${a.title}</h1>\n${meta}<div class="content">\n${a.content}\n</div>\n</article>`;
+                    });
+                    const htmlContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${args.project_name || 'Exported Articles'}</title>
+<style>
+body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; }
+article { margin-bottom: 3rem; padding-bottom: 2rem; border-bottom: 1px solid #e2e8f0; }
+.article-meta { color: #64748b; font-size: 0.875rem; margin-bottom: 1rem; }
+h1 { color: #0f172a; }
+</style>
+</head>
+<body>
+${htmlParts.join('\n\n')}
+</body>
+</html>`;
+                    await fs.mkdir(path.dirname(args.output_path), { recursive: true });
+                    await fs.writeFile(args.output_path, htmlContent, 'utf-8');
+                    outputInfo = {
+                        output_file: args.output_path,
+                        file_size: `${(Buffer.byteLength(htmlContent) / 1024).toFixed(1)} KB`,
+                    };
+                    break;
+                }
+            }
+            return {
+                content: [{
+                        type: 'text', text: JSON.stringify({
+                            status: 'success',
+                            format: args.format,
+                            articles_exported: filtered.length,
+                            total_before_filter: args.articles.length,
+                            ...outputInfo,
+                        }, null, 2)
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: `Bulk export failed: ${err.message}` }, null, 2) }] };
+        }
+    });
+}
+//# sourceMappingURL=csv.js.map