@project-ava-supernova/core 0.2.71

package/dist/tools/document-manage.js

@@ -0,0 +1,665 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, extname } from 'node:path';
+import { TEMPLATES, getTemplate } from './document-templates.js';
+import { titleParagraph, headingParagraph, bodyParagraph, bulletParagraph, themedTable, sectionProperties, getStyleProfile, pdfTitle, pdfHeading, pdfBody, pdfBullet, pdfTable, } from './document-styling.js';
+export class DocumentManageTool {
+    name = 'document_manage';
+    description = 'Create, read, edit, and export documents (Word, Excel, PDF, CSV, Markdown)';
+    riskLevel = 'write';
+    requiresConfirmation = true;
+    schema = {
+        name: 'document_manage',
+        description: 'Create, read, edit, and export documents. Supports Word (.docx), Excel (.xlsx), PDF (.pdf), CSV (.csv), and Markdown (.md). ' +
+            'Use templates for common document types. Optional dependencies: npm install docx exceljs pdfkit for full format support. ' +
+            'CSV and Markdown work with no extra dependencies. ' +
+            'Note: editing a .docx is destructive — the file is recreated from scratch and any custom formatting in the original (fonts, colors, images, complex tables, headers/footers) will be lost. Only text content is preserved. For preserving formatting, edit the document in Word directly.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['create', 'edit', 'read', 'export', 'list_templates', 'from_template'],
+                    description: 'The action to perform',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Path for the document (required for create, edit, read, export)',
+                },
+                format: {
+                    type: 'string',
+                    enum: ['docx', 'xlsx', 'pdf', 'csv', 'md'],
+                    description: 'Document format (auto-detected from file extension if not specified)',
+                },
+                content: {
+                    type: 'object',
+                    description: 'Structured content. For docs: { title?, sections: [{ heading?, text?, list?, table?: { headers, rows } }] }. For csv: { headers, rows }. For xlsx: { sheets: [{ name, headers, rows }] }',
+                },
+                template: {
+                    type: 'string',
+                    enum: [...TEMPLATES],
+                    description: 'Template name for from_template action',
+                },
+                template_data: {
+                    type: 'object',
+                    description: 'Data to fill the template with',
+                },
+                export_format: {
+                    type: 'string',
+                    enum: ['docx', 'xlsx', 'pdf', 'csv', 'md'],
+                    description: 'Target format for export action',
+                },
+                export_path: {
+                    type: 'string',
+                    description: 'Output path for export action',
+                },
+            },
+            required: ['action'],
+        },
+    };
+    async execute(args, context) {
+        const action = args.action;
+        switch (action) {
+            case 'create': return this.handleCreate(args, context);
+            case 'edit': return this.handleEdit(args, context);
+            case 'read': return this.handleRead(args, context);
+            case 'export': return this.handleExport(args, context);
+            case 'list_templates': return this.handleListTemplates();
+            case 'from_template': return this.handleFromTemplate(args, context);
+            default:
+                return { success: false, output: `Unknown action: ${action}` };
+        }
+    }
+    // ── Create ─────────────────────────────────────────────────────────────────
+    async handleCreate(args, context) {
+        const filePath = args.file_path;
+        if (!filePath)
+            return { success: false, output: 'Missing required field: file_path' };
+        const format = this.detectFormat(filePath, args.format);
+        if (!format)
+            return { success: false, output: 'Cannot determine format. Specify format or use a known extension (.docx, .xlsx, .pdf, .csv, .md)' };
+        const content = args.content;
+        const fullPath = this.resolvePath(filePath, context.cwd);
+        await mkdir(dirname(fullPath), { recursive: true });
+        switch (format) {
+            case 'csv': return this.createCsv(fullPath, content);
+            case 'md': return this.createMarkdown(fullPath, content);
+            case 'docx': return this.createDocx(fullPath, content);
+            case 'xlsx': return this.createXlsx(fullPath, content);
+            case 'pdf': return this.createPdf(fullPath, content);
+            default: return { success: false, output: `Unsupported format: ${format}` };
+        }
+    }
+    // ── Edit ───────────────────────────────────────────────────────────────────
+    async handleEdit(args, context) {
+        const filePath = args.file_path;
+        if (!filePath)
+            return { success: false, output: 'Missing required field: file_path' };
+        const fullPath = this.resolvePath(filePath, context.cwd);
+        if (!existsSync(fullPath))
+            return { success: false, output: `File not found: ${filePath}` };
+        const format = this.detectFormat(filePath, args.format);
+        const content = args.content;
+        switch (format) {
+            case 'csv': return this.editCsv(fullPath, content);
+            case 'md': return this.editMarkdown(fullPath, content);
+            case 'docx': return this.editDocx(fullPath, content);
+            case 'xlsx': return this.editXlsx(fullPath, content);
+            case 'pdf': return { success: false, output: 'PDFs cannot be edited directly. Recreate the document or edit the source format.' };
+            default: return { success: false, output: `Unsupported format for editing: ${format}` };
+        }
+    }
+    // ── Read ───────────────────────────────────────────────────────────────────
+    async handleRead(args, context) {
+        const filePath = args.file_path;
+        if (!filePath)
+            return { success: false, output: 'Missing required field: file_path' };
+        const fullPath = this.resolvePath(filePath, context.cwd);
+        if (!existsSync(fullPath))
+            return { success: false, output: `File not found: ${filePath}` };
+        const format = this.detectFormat(filePath, args.format);
+        switch (format) {
+            case 'csv': return this.readCsv(fullPath);
+            case 'md': return this.readMarkdown(fullPath);
+            case 'docx': return this.readDocx(fullPath);
+            case 'xlsx': return this.readXlsx(fullPath);
+            case 'pdf': return this.readPdf(fullPath);
+            default: return { success: false, output: `Unsupported format for reading: ${format}` };
+        }
+    }
+    // ── Export ─────────────────────────────────────────────────────────────────
+    async handleExport(args, context) {
+        const filePath = args.file_path;
+        const exportFormat = args.export_format;
+        const exportPath = args.export_path;
+        if (!filePath)
+            return { success: false, output: 'Missing required field: file_path' };
+        if (!exportFormat)
+            return { success: false, output: 'Missing required field: export_format' };
+        const fullPath = this.resolvePath(filePath, context.cwd);
+        if (!existsSync(fullPath))
+            return { success: false, output: `File not found: ${filePath}` };
+        const sourceFormat = this.detectFormat(filePath);
+        const outPath = exportPath
+            ? this.resolvePath(exportPath, context.cwd)
+            : fullPath.replace(new RegExp(`\\.${sourceFormat}$`), `.${exportFormat}`);
+        await mkdir(dirname(outPath), { recursive: true });
+        // Read source content
+        const readResult = await this.handleRead({ file_path: filePath, format: sourceFormat }, context);
+        if (!readResult.success)
+            return readResult;
+        // For MD→DOCX, MD→PDF, CSV→XLSX: parse the source and create in target format
+        if (sourceFormat === 'md' && (exportFormat === 'docx' || exportFormat === 'pdf')) {
+            const raw = await readFile(fullPath, 'utf-8');
+            const content = this.markdownToContent(raw);
+            const createResult = exportFormat === 'docx'
+                ? await this.createDocx(outPath, content)
+                : await this.createPdf(outPath, content);
+            if (createResult.success) {
+                return { success: true, output: `Exported ${filePath} → ${outPath} (${sourceFormat} → ${exportFormat})` };
+            }
+            return createResult;
+        }
+        if (sourceFormat === 'csv' && exportFormat === 'xlsx') {
+            const raw = await readFile(fullPath, 'utf-8');
+            const csvContent = this.parseCsvString(raw);
+            const xlsxContent = {
+                sheets: [{ name: 'Sheet1', headers: csvContent.headers, rows: csvContent.rows }],
+            };
+            const createResult = await this.createXlsx(outPath, xlsxContent);
+            if (createResult.success) {
+                return { success: true, output: `Exported ${filePath} → ${outPath} (csv → xlsx)` };
+            }
+            return createResult;
+        }
+        if (exportFormat === 'md') {
+            // Any → Markdown: use the read output as content
+            await writeFile(outPath, readResult.output, 'utf-8');
+            return { success: true, output: `Exported ${filePath} → ${outPath} (${sourceFormat} → md)` };
+        }
+        return { success: false, output: `Export from ${sourceFormat} to ${exportFormat} is not supported.` };
+    }
+    // ── Templates ──────────────────────────────────────────────────────────────
+    handleListTemplates() {
+        const lines = TEMPLATES.map(t => `- **${t}**`);
+        return {
+            success: true,
+            output: `Available templates:\n${lines.join('\n')}\n\nUse action "from_template" with template name and optional template_data to create a document.`,
+        };
+    }
+    async handleFromTemplate(args, context) {
+        const template = args.template;
+        if (!template || !TEMPLATES.includes(template)) {
+            return { success: false, output: `Invalid template. Available: ${TEMPLATES.join(', ')}` };
+        }
+        const filePath = args.file_path;
+        if (!filePath)
+            return { success: false, output: 'Missing required field: file_path' };
+        const format = this.detectFormat(filePath, args.format) ?? 'md';
+        const templateData = args.template_data;
+        const content = getTemplate(template, templateData);
+        // Per-template styling profile (margins, cover page, footer flags) so a
+        // letter actually looks like a letter and an invoice like an invoice.
+        const profile = getStyleProfile(template);
+        const fullPath = this.resolvePath(filePath, context.cwd);
+        await mkdir(dirname(fullPath), { recursive: true });
+        switch (format) {
+            case 'md': return this.createMarkdown(fullPath, content);
+            case 'csv': {
+                // Convert first table in template to CSV
+                const table = content.sections.find(s => s.table)?.table;
+                if (table) {
+                    return this.createCsv(fullPath, { headers: table.headers, rows: table.rows });
+                }
+                return { success: false, output: 'Template has no table data for CSV format.' };
+            }
+            case 'docx': return this.createDocx(fullPath, content, profile);
+            case 'xlsx': {
+                const table = content.sections.find(s => s.table)?.table;
+                if (table) {
+                    return this.createXlsx(fullPath, { sheets: [{ name: 'Sheet1', headers: table.headers, rows: table.rows }] });
+                }
+                return { success: false, output: 'Template has no table data for XLSX format.' };
+            }
+            case 'pdf': return this.createPdf(fullPath, content, profile);
+            default: return { success: false, output: `Unsupported format for template: ${format}` };
+        }
+    }
+    // ── CSV (native) ───────────────────────────────────────────────────────────
+    async createCsv(filePath, content) {
+        const headers = content?.headers ?? [];
+        const rows = content?.rows ?? [];
+        const lines = [headers.map(h => this.csvEscape(h)).join(',')];
+        for (const row of rows) {
+            lines.push(row.map(cell => this.csvEscape(String(cell))).join(','));
+        }
+        await writeFile(filePath, lines.join('\n'), 'utf-8');
+        return { success: true, output: `Created CSV: ${filePath} (${rows.length} rows, ${headers.length} columns)` };
+    }
+    async readCsv(filePath) {
+        const raw = await readFile(filePath, 'utf-8');
+        const parsed = this.parseCsvString(raw);
+        const lines = [parsed.headers.join(' | ')];
+        lines.push(parsed.headers.map(() => '---').join(' | '));
+        for (const row of parsed.rows.slice(0, 50)) {
+            lines.push(row.join(' | '));
+        }
+        const truncated = parsed.rows.length > 50 ? `\n... and ${parsed.rows.length - 50} more rows` : '';
+        return { success: true, output: `CSV: ${filePath} (${parsed.rows.length} rows)\n\n${lines.join('\n')}${truncated}` };
+    }
+    async editCsv(filePath, content) {
+        if (!content)
+            return { success: false, output: 'Missing content for edit. Provide { headers, rows } to append.' };
+        const existing = await readFile(filePath, 'utf-8');
+        const newRows = (content.rows ?? []).map(row => row.map(cell => this.csvEscape(String(cell))).join(','));
+        const updated = existing.trimEnd() + '\n' + newRows.join('\n');
+        await writeFile(filePath, updated, 'utf-8');
+        return { success: true, output: `Appended ${newRows.length} rows to ${filePath}` };
+    }
+    csvEscape(value) {
+        if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+            return `"${value.replace(/"/g, '""')}"`;
+        }
+        return value;
+    }
+    parseCsvString(raw) {
+        const lines = raw.trim().split('\n');
+        if (lines.length === 0)
+            return { headers: [], rows: [] };
+        const headers = this.parseCsvLine(lines[0]);
+        const rows = lines.slice(1).map(l => this.parseCsvLine(l));
+        return { headers, rows };
+    }
+    parseCsvLine(line) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (inQuotes) {
+                if (ch === '"' && line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else if (ch === '"') {
+                    inQuotes = false;
+                }
+                else {
+                    current += ch;
+                }
+            }
+            else {
+                if (ch === '"') {
+                    inQuotes = true;
+                }
+                else if (ch === ',') {
+                    result.push(current);
+                    current = '';
+                }
+                else {
+                    current += ch;
+                }
+            }
+        }
+        result.push(current);
+        return result;
+    }
+    // ── Markdown (native) ──────────────────────────────────────────────────────
+    async createMarkdown(filePath, content) {
+        const lines = [];
+        if (content?.title)
+            lines.push(`# ${content.title}`, '');
+        for (const section of content?.sections ?? []) {
+            if (section.heading)
+                lines.push(`## ${section.heading}`, '');
+            if (section.text)
+                lines.push(section.text, '');
+            if (section.list) {
+                for (const item of section.list)
+                    lines.push(`- ${item}`);
+                lines.push('');
+            }
+            if (section.table) {
+                lines.push(`| ${section.table.headers.join(' | ')} |`);
+                lines.push(`| ${section.table.headers.map(() => '---').join(' | ')} |`);
+                for (const row of section.table.rows) {
+                    lines.push(`| ${row.join(' | ')} |`);
+                }
+                lines.push('');
+            }
+        }
+        await writeFile(filePath, lines.join('\n'), 'utf-8');
+        const sectionCount = content?.sections?.length ?? 0;
+        return { success: true, output: `Created Markdown: ${filePath} (${sectionCount} sections)` };
+    }
+    async readMarkdown(filePath) {
+        const raw = await readFile(filePath, 'utf-8');
+        const lineCount = raw.split('\n').length;
+        return { success: true, output: `Markdown: ${filePath} (${lineCount} lines)\n\n${raw.slice(0, 3000)}${raw.length > 3000 ? '\n... truncated' : ''}` };
+    }
+    async editMarkdown(filePath, content) {
+        if (!content)
+            return { success: false, output: 'Missing content for edit.' };
+        const existing = await readFile(filePath, 'utf-8');
+        const newContent = [];
+        for (const section of content.sections ?? []) {
+            if (section.heading)
+                newContent.push(`\n## ${section.heading}\n`);
+            if (section.text)
+                newContent.push(section.text);
+            if (section.list)
+                newContent.push(...section.list.map(i => `- ${i}`));
+        }
+        await writeFile(filePath, existing.trimEnd() + '\n' + newContent.join('\n') + '\n', 'utf-8');
+        return { success: true, output: `Appended ${content.sections.length} sections to ${filePath}` };
+    }
+    markdownToContent(raw) {
+        const lines = raw.split('\n');
+        let title;
+        const sections = [];
+        let current = {};
+        for (const line of lines) {
+            if (line.startsWith('# ') && !title) {
+                title = line.slice(2).trim();
+            }
+            else if (line.startsWith('## ')) {
+                if (current.heading || current.text)
+                    sections.push(current);
+                current = { heading: line.slice(3).trim() };
+            }
+            else if (line.startsWith('- ')) {
+                if (!current.list)
+                    current.list = [];
+                current.list.push(line.slice(2).trim());
+            }
+            else if (line.trim()) {
+                current.text = (current.text ? current.text + '\n' : '') + line;
+            }
+        }
+        if (current.heading || current.text || current.list)
+            sections.push(current);
+        return { title, sections };
+    }
+    // ── DOCX (optional: docx package) ──────────────────────────────────────────
+    async createDocx(filePath, content, profile) {
+        let docx;
+        try {
+            docx = await import('docx');
+        }
+        catch {
+            return { success: false, output: 'docx package is not installed. Install it with: npm install docx' };
+        }
+        const { Document, Packer } = docx;
+        const styleProfile = profile ?? getStyleProfile();
+        const children = [];
+        if (content?.title) {
+            children.push(titleParagraph(docx, content.title));
+        }
+        for (const section of content?.sections ?? []) {
+            if (section.heading) {
+                children.push(headingParagraph(docx, section.heading, 1));
+            }
+            if (section.text) {
+                for (const para of section.text.split('\n')) {
+                    if (para.trim())
+                        children.push(bodyParagraph(docx, para));
+                }
+            }
+            if (section.list) {
+                for (const item of section.list) {
+                    children.push(bulletParagraph(docx, item));
+                }
+            }
+            if (section.table) {
+                children.push(themedTable(docx, {
+                    headers: section.table.headers,
+                    rows: section.table.rows,
+                }));
+            }
+        }
+        const doc = new Document({
+            sections: [{
+                    properties: sectionProperties(styleProfile),
+                    children,
+                }],
+        });
+        const buffer = await Packer.toBuffer(doc);
+        await writeFile(filePath, buffer);
+        return { success: true, output: `Created Word document: ${filePath} (${content?.sections?.length ?? 0} sections, Ava-themed)` };
+    }
+    async readDocx(filePath) {
+        let mammoth;
+        try {
+            mammoth = await import('mammoth');
+        }
+        catch {
+            // Fallback: just report file exists
+            const raw = await readFile(filePath);
+            return { success: true, output: `Word document: ${filePath} (${raw.length} bytes). Install mammoth for text extraction: npm install mammoth` };
+        }
+        const result = await mammoth.extractRawText({ path: filePath });
+        return { success: true, output: `Word document: ${filePath}\n\n${result.value.slice(0, 3000)}${result.value.length > 3000 ? '\n... truncated' : ''}` };
+    }
+    async editDocx(filePath, content) {
+        // ⚠ Destructive: the `docx` library is creation-first and has no
+        // round-trip-preserving edit API. We read the existing file as plain
+        // text via `mammoth` (formatting is lost in the read), append new
+        // sections, then RECREATE the file from scratch. This means any
+        // custom formatting in the original — fonts, colors, images, tables
+        // beyond plain text, headers/footers, comments — will be lost.
+        //
+        // For a non-destructive edit, the user should either: (a) keep the
+        // source as Markdown and export to .docx on demand, or (b) accept
+        // the loss and use this tool. A future swap to docx4js or direct
+        // OOXML manipulation would address this; not done yet.
+        const readResult = await this.readDocx(filePath);
+        if (!readResult.success)
+            return readResult;
+        // Parse existing text into content structure
+        const existingContent = this.markdownToContent(readResult.output);
+        // Merge new sections
+        const merged = {
+            title: existingContent.title,
+            sections: [...existingContent.sections, ...(content?.sections ?? [])],
+        };
+        const result = await this.createDocx(filePath, merged);
+        if (result.success) {
+            return {
+                ...result,
+                output: result.output + '\n\n⚠ Note: editing a .docx recreates the file. Any custom formatting (fonts, colors, images, complex tables, headers/footers) in the original was lost — only text content was preserved. To preserve formatting, edit the document in Word directly.',
+            };
+        }
+        return result;
+    }
+    // ── XLSX (optional: exceljs package) ───────────────────────────────────────
+    async createXlsx(filePath, content) {
+        let ExcelJS;
+        try {
+            ExcelJS = await import('exceljs');
+        }
+        catch {
+            return { success: false, output: 'exceljs package is not installed. Install it with: npm install exceljs' };
+        }
+        const workbook = new (ExcelJS.default?.Workbook || ExcelJS.Workbook)();
+        let totalRows = 0;
+        // If no structured content provided, try to parse plain text content from args
+        const sheets = content?.sheets ?? this.parseTextToSheets(content);
+        for (const sheet of sheets) {
+            const ws = workbook.addWorksheet(sheet.name);
+            if (sheet.headers.length > 0) {
+                const headerRow = ws.addRow(sheet.headers);
+                headerRow.font = { bold: true, color: { argb: 'FFFFFFFF' } };
+                headerRow.eachCell((cell) => {
+                    cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF4472C4' } };
+                    cell.border = {
+                        bottom: { style: 'thin', color: { argb: 'FF2F5496' } },
+                    };
+                });
+            }
+            for (const row of sheet.rows) {
+                ws.addRow(row);
+                totalRows++;
+            }
+            // Auto-width columns based on content
+            ws.columns?.forEach((col) => {
+                if (!col)
+                    return;
+                let maxLen = 10;
+                col.eachCell?.({ includeEmpty: false }, (cell) => {
+                    const len = String(cell.value ?? '').length;
+                    if (len > maxLen)
+                        maxLen = len;
+                });
+                col.width = Math.min(maxLen + 2, 50);
+            });
+        }
+        await workbook.xlsx.writeFile(filePath);
+        return { success: true, output: `Created spreadsheet: ${filePath} (${content?.sheets?.length ?? 1} sheets, ${totalRows} rows)` };
+    }
+    async readXlsx(filePath) {
+        let ExcelJS;
+        try {
+            ExcelJS = await import('exceljs');
+        }
+        catch {
+            return { success: false, output: 'exceljs package is not installed. Install it with: npm install exceljs' };
+        }
+        const workbook = new (ExcelJS.default?.Workbook || ExcelJS.Workbook)();
+        await workbook.xlsx.readFile(filePath);
+        const parts = [];
+        workbook.eachSheet((sheet) => {
+            parts.push(`### ${sheet.name}`);
+            const rows = [];
+            sheet.eachRow({ includeEmpty: false }, (row, rowNum) => {
+                const values = row.values;
+                // Row values are 1-indexed, skip index 0
+                const cells = values.slice(1).map((v) => String(v ?? ''));
+                if (rowNum === 1) {
+                    rows.push(cells.join(' | '));
+                    rows.push(cells.map(() => '---').join(' | '));
+                }
+                else {
+                    rows.push(cells.join(' | '));
+                }
+            });
+            parts.push(rows.join('\n'));
+        });
+        return { success: true, output: `Spreadsheet: ${filePath}\n\n${parts.join('\n\n')}` };
+    }
+    async editXlsx(filePath, content) {
+        let ExcelJS;
+        try {
+            ExcelJS = await import('exceljs');
+        }
+        catch {
+            return { success: false, output: 'exceljs package is not installed. Install it with: npm install exceljs' };
+        }
+        const workbook = new (ExcelJS.default?.Workbook || ExcelJS.Workbook)();
+        await workbook.xlsx.readFile(filePath);
+        let addedRows = 0;
+        for (const sheet of content?.sheets ?? []) {
+            let ws = workbook.getWorksheet(sheet.name);
+            if (!ws)
+                ws = workbook.addWorksheet(sheet.name);
+            for (const row of sheet.rows) {
+                ws.addRow(row);
+                addedRows++;
+            }
+        }
+        await workbook.xlsx.writeFile(filePath);
+        return { success: true, output: `Updated spreadsheet: ${filePath} (added ${addedRows} rows)` };
+    }
+    // ── PDF (optional: pdfkit + pdf-parse) ─────────────────────────────────────
+    async createPdf(filePath, content, _profile) {
+        let PDFDocument;
+        try {
+            // @ts-expect-error — pdfkit is an optional peer dependency
+            const pdfkit = await import('pdfkit');
+            PDFDocument = pdfkit.default || pdfkit;
+        }
+        catch {
+            return { success: false, output: 'pdfkit package is not installed. Install it with: npm install pdfkit' };
+        }
+        return new Promise((resolve) => {
+            const doc = new PDFDocument({ margin: 56 }); // ~0.78", a touch tighter than docx defaults
+            const chunks = [];
+            doc.on('data', (chunk) => chunks.push(chunk));
+            doc.on('end', async () => {
+                const buffer = Buffer.concat(chunks);
+                await writeFile(filePath, buffer);
+                resolve({ success: true, output: `Created PDF: ${filePath} (${content?.sections?.length ?? 0} sections, Ava-themed)` });
+            });
+            if (content?.title) {
+                pdfTitle(doc, content.title);
+            }
+            for (const section of content?.sections ?? []) {
+                if (section.heading)
+                    pdfHeading(doc, section.heading, 1);
+                if (section.text) {
+                    for (const para of section.text.split(/\n\n+/)) {
+                        if (para.trim())
+                            pdfBody(doc, para.trim());
+                    }
+                }
+                if (section.list) {
+                    for (const item of section.list)
+                        pdfBullet(doc, item);
+                    doc.moveDown(0.4);
+                }
+                if (section.table) {
+                    pdfTable(doc, { headers: section.table.headers, rows: section.table.rows });
+                }
+            }
+            doc.end();
+        });
+    }
+    async readPdf(filePath) {
+        let pdfParse;
+        try {
+            const mod = await import('pdf-parse');
+            pdfParse = mod.default || mod;
+        }
+        catch {
+            const raw = await readFile(filePath);
+            return { success: true, output: `PDF: ${filePath} (${raw.length} bytes). Install pdf-parse for text extraction: npm install pdf-parse` };
+        }
+        const buffer = await readFile(filePath);
+        const data = await pdfParse(buffer);
+        return { success: true, output: `PDF: ${filePath} (${data.numpages} pages)\n\n${data.text.slice(0, 3000)}${data.text.length > 3000 ? '\n... truncated' : ''}` };
+    }
+    // ── Helpers ────────────────────────────────────────────────────────────────
+    detectFormat(filePath, explicit) {
+        if (explicit)
+            return explicit;
+        const ext = extname(filePath).toLowerCase().replace('.', '');
+        if (['docx', 'xlsx', 'pdf', 'csv', 'md'].includes(ext))
+            return ext;
+        if (ext === 'markdown')
+            return 'md';
+        return null;
+    }
+    resolvePath(filePath, cwd) {
+        if (filePath.startsWith('/') || /^[A-Za-z]:/.test(filePath))
+            return filePath;
+        return `${cwd}/${filePath}`;
+    }
+    /**
+     * Parse plain text content into spreadsheet sheets.
+     * Splits by newlines for rows and commas/tabs for columns.
+     * First row is treated as headers.
+     */
+    parseTextToSheets(rawContent) {
+        if (typeof rawContent === 'string' && rawContent.trim()) {
+            const lines = rawContent.trim().split('\n').map(l => l.trim()).filter(Boolean);
+            if (lines.length === 0)
+                return [{ name: 'Sheet1', headers: [], rows: [] }];
+            const delimiter = lines[0].includes('\t') ? '\t' : ',';
+            const parsed = lines.map(line => line.split(delimiter).map(cell => cell.trim()));
+            const headers = parsed[0];
+            const rows = parsed.slice(1);
+            return [{ name: 'Sheet1', headers, rows }];
+        }
+        return [{ name: 'Sheet1', headers: [], rows: [] }];
+    }
+}
+//# sourceMappingURL=document-manage.js.map