cowork-os 0.3.21

package/dist/electron/electron/agent/skills/presentation.js

@@ -0,0 +1,367 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentationBuilder = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const pptxgenjs_1 = __importDefault(require("pptxgenjs"));
+/**
+ * PresentationBuilder creates PowerPoint presentations (.pptx) using pptxgenjs
+ */
+class PresentationBuilder {
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async create(outputPath, slides, options = {}) {
+        const ext = path.extname(outputPath).toLowerCase();
+        // If markdown is explicitly requested, create markdown slides
+        if (ext === '.md') {
+            await this.createMarkdownSlides(outputPath, slides);
+            return;
+        }
+        // Create PowerPoint presentation
+        const pptx = new pptxgenjs_1.default();
+        // Set presentation metadata
+        pptx.author = options.author || 'CoWork OS';
+        pptx.title = options.title || 'Presentation';
+        pptx.subject = options.subject || '';
+        pptx.company = 'CoWork OS';
+        // Set slide size
+        if (options.slideSize === 'standard') {
+            pptx.defineLayout({ name: 'STANDARD', width: 10, height: 7.5 });
+            pptx.layout = 'STANDARD';
+        }
+        else {
+            // Default to widescreen 16:9
+            pptx.defineLayout({ name: 'WIDESCREEN', width: 13.33, height: 7.5 });
+            pptx.layout = 'WIDESCREEN';
+        }
+        const themeColor = options.themeColor || '2B579A'; // Default blue
+        for (let i = 0; i < slides.length; i++) {
+            const slideData = slides[i];
+            const slide = pptx.addSlide();
+            // Add speaker notes if provided
+            if (slideData.notes) {
+                slide.addNotes(slideData.notes);
+            }
+            const layout = slideData.layout || (i === 0 ? 'title' : 'titleContent');
+            switch (layout) {
+                case 'title':
+                    this.createTitleSlide(slide, slideData, themeColor);
+                    break;
+                case 'titleContent':
+                    this.createTitleContentSlide(slide, slideData, themeColor);
+                    break;
+                case 'twoColumn':
+                    this.createTwoColumnSlide(slide, slideData, themeColor);
+                    break;
+                case 'imageOnly':
+                    await this.createImageSlide(slide, slideData, themeColor);
+                    break;
+                case 'blank':
+                    // Just add title if provided
+                    if (slideData.title) {
+                        slide.addText(slideData.title, {
+                            x: 0.5,
+                            y: 0.5,
+                            w: '90%',
+                            fontSize: 28,
+                            bold: true,
+                            color: themeColor
+                        });
+                    }
+                    break;
+                default:
+                    this.createTitleContentSlide(slide, slideData, themeColor);
+            }
+        }
+        // Write the file
+        await pptx.writeFile({ fileName: outputPath });
+    }
+    createTitleSlide(slide, data, themeColor) {
+        // Background accent
+        slide.addShape('rect', {
+            x: 0,
+            y: 3,
+            w: '100%',
+            h: 1.5,
+            fill: { color: themeColor }
+        });
+        // Main title
+        slide.addText(data.title, {
+            x: 0.5,
+            y: 2.5,
+            w: '90%',
+            h: 1.5,
+            fontSize: 44,
+            bold: true,
+            color: '363636',
+            align: 'center',
+            valign: 'middle'
+        });
+        // Subtitle
+        if (data.subtitle) {
+            slide.addText(data.subtitle, {
+                x: 0.5,
+                y: 4.5,
+                w: '90%',
+                h: 1,
+                fontSize: 24,
+                color: '666666',
+                align: 'center',
+                valign: 'middle'
+            });
+        }
+        // Content bullets on title slide (if provided)
+        if (data.content && data.content.length > 0) {
+            slide.addText(data.content.join('\n'), {
+                x: 0.5,
+                y: 5.5,
+                w: '90%',
+                fontSize: 18,
+                color: '888888',
+                align: 'center'
+            });
+        }
+    }
+    createTitleContentSlide(slide, data, themeColor) {
+        // Title bar
+        slide.addShape('rect', {
+            x: 0,
+            y: 0,
+            w: '100%',
+            h: 1.2,
+            fill: { color: themeColor }
+        });
+        // Title text
+        slide.addText(data.title, {
+            x: 0.5,
+            y: 0.2,
+            w: '90%',
+            h: 0.8,
+            fontSize: 32,
+            bold: true,
+            color: 'FFFFFF'
+        });
+        // Content bullets
+        if (data.content && data.content.length > 0) {
+            const bulletItems = data.content.map(item => ({
+                text: item,
+                options: {
+                    bullet: { type: 'bullet' },
+                    fontSize: 20,
+                    color: '363636',
+                    paraSpaceBefore: 8,
+                    paraSpaceAfter: 8
+                }
+            }));
+            slide.addText(bulletItems, {
+                x: 0.5,
+                y: 1.5,
+                w: '90%',
+                h: 5.5,
+                valign: 'top'
+            });
+        }
+        // Subtitle (below content if exists)
+        if (data.subtitle) {
+            slide.addText(data.subtitle, {
+                x: 0.5,
+                y: 6.8,
+                w: '90%',
+                fontSize: 14,
+                color: '888888',
+                italic: true
+            });
+        }
+    }
+    createTwoColumnSlide(slide, data, themeColor) {
+        // Title bar
+        slide.addShape('rect', {
+            x: 0,
+            y: 0,
+            w: '100%',
+            h: 1.2,
+            fill: { color: themeColor }
+        });
+        // Title text
+        slide.addText(data.title, {
+            x: 0.5,
+            y: 0.2,
+            w: '90%',
+            h: 0.8,
+            fontSize: 32,
+            bold: true,
+            color: 'FFFFFF'
+        });
+        if (data.content && data.content.length > 0) {
+            // Split content into two columns
+            const midpoint = Math.ceil(data.content.length / 2);
+            const leftContent = data.content.slice(0, midpoint);
+            const rightContent = data.content.slice(midpoint);
+            // Left column
+            const leftItems = leftContent.map(item => ({
+                text: item,
+                options: {
+                    bullet: { type: 'bullet' },
+                    fontSize: 18,
+                    color: '363636',
+                    paraSpaceBefore: 6,
+                    paraSpaceAfter: 6
+                }
+            }));
+            slide.addText(leftItems, {
+                x: 0.5,
+                y: 1.5,
+                w: 5.8,
+                h: 5.5,
+                valign: 'top'
+            });
+            // Right column
+            if (rightContent.length > 0) {
+                const rightItems = rightContent.map(item => ({
+                    text: item,
+                    options: {
+                        bullet: { type: 'bullet' },
+                        fontSize: 18,
+                        color: '363636',
+                        paraSpaceBefore: 6,
+                        paraSpaceAfter: 6
+                    }
+                }));
+                slide.addText(rightItems, {
+                    x: 6.8,
+                    y: 1.5,
+                    w: 5.8,
+                    h: 5.5,
+                    valign: 'top'
+                });
+            }
+        }
+    }
+    async createImageSlide(slide, data, themeColor) {
+        // Title bar
+        slide.addShape('rect', {
+            x: 0,
+            y: 0,
+            w: '100%',
+            h: 1.2,
+            fill: { color: themeColor }
+        });
+        // Title text
+        slide.addText(data.title, {
+            x: 0.5,
+            y: 0.2,
+            w: '90%',
+            h: 0.8,
+            fontSize: 32,
+            bold: true,
+            color: 'FFFFFF'
+        });
+        // Add image if path provided
+        if (data.imagePath) {
+            const fullPath = path.isAbsolute(data.imagePath)
+                ? data.imagePath
+                : path.join(this.workspace.path, data.imagePath);
+            try {
+                const imageBuffer = await fs.readFile(fullPath);
+                const base64 = imageBuffer.toString('base64');
+                const ext = path.extname(data.imagePath).toLowerCase().slice(1);
+                const mimeType = ext === 'jpg' ? 'jpeg' : ext;
+                slide.addImage({
+                    data: `data:image/${mimeType};base64,${base64}`,
+                    x: 1,
+                    y: 1.5,
+                    w: 11,
+                    h: 5.5,
+                    sizing: { type: 'contain', w: 11, h: 5.5 }
+                });
+            }
+            catch (error) {
+                // If image can't be loaded, add placeholder text
+                slide.addText(`[Image: ${data.imagePath}]`, {
+                    x: 1,
+                    y: 3,
+                    w: 11,
+                    h: 1,
+                    fontSize: 16,
+                    color: '888888',
+                    align: 'center'
+                });
+            }
+        }
+        // Add caption from content
+        if (data.content && data.content.length > 0) {
+            slide.addText(data.content[0], {
+                x: 0.5,
+                y: 6.8,
+                w: '90%',
+                fontSize: 14,
+                color: '666666',
+                align: 'center',
+                italic: true
+            });
+        }
+    }
+    /**
+     * Creates Markdown slides (fallback)
+     */
+    async createMarkdownSlides(outputPath, slides) {
+        const markdown = slides
+            .map((slide, index) => {
+            const lines = [
+                '---',
+                `# Slide ${index + 1}: ${slide.title}`,
+                ''
+            ];
+            if (slide.subtitle) {
+                lines.push(`*${slide.subtitle}*`, '');
+            }
+            if (slide.content && slide.content.length > 0) {
+                lines.push(...slide.content.map(item => `- ${item}`), '');
+            }
+            if (slide.notes) {
+                lines.push('', '> Notes: ' + slide.notes, '');
+            }
+            return lines.join('\n');
+        })
+            .join('\n');
+        await fs.writeFile(outputPath, markdown, 'utf-8');
+    }
+}
+exports.PresentationBuilder = PresentationBuilder;

package/dist/electron/electron/agent/skills/spreadsheet.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpreadsheetBuilder = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const exceljs_1 = __importDefault(require("exceljs"));
+/**
+ * SpreadsheetBuilder creates Excel spreadsheets (.xlsx) using exceljs
+ */
+class SpreadsheetBuilder {
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    async create(outputPath, sheets, options = {}) {
+        if (sheets.length === 0) {
+            throw new Error('At least one sheet is required');
+        }
+        const ext = path.extname(outputPath).toLowerCase();
+        // If CSV is explicitly requested, use CSV format
+        if (ext === '.csv') {
+            await this.createCSV(outputPath, sheets[0]);
+            return;
+        }
+        // Create Excel workbook
+        const workbook = new exceljs_1.default.Workbook();
+        workbook.creator = 'CoWork OS';
+        workbook.created = new Date();
+        for (const sheetData of sheets) {
+            const worksheet = workbook.addWorksheet(sheetData.name);
+            // Add all rows
+            for (let rowIndex = 0; rowIndex < sheetData.data.length; rowIndex++) {
+                const rowData = sheetData.data[rowIndex];
+                const row = worksheet.addRow(rowData);
+                // Style header row if specified
+                if (rowIndex === 0 && sheetData.hasHeader !== false) {
+                    row.font = { bold: true };
+                    row.fill = {
+                        type: 'pattern',
+                        pattern: 'solid',
+                        fgColor: { argb: 'FFE0E0E0' }
+                    };
+                }
+            }
+            // Set column widths
+            if (sheetData.columnWidths) {
+                sheetData.columnWidths.forEach((width, index) => {
+                    const column = worksheet.getColumn(index + 1);
+                    column.width = width;
+                });
+            }
+            else if (options.autoFitColumns !== false) {
+                // Auto-fit columns based on content
+                worksheet.columns.forEach(column => {
+                    let maxLength = 10;
+                    column.eachCell?.({ includeEmpty: true }, cell => {
+                        const cellValue = cell.value;
+                        const length = cellValue ? String(cellValue).length : 0;
+                        if (length > maxLength) {
+                            maxLength = Math.min(length, 50); // Cap at 50 characters
+                        }
+                    });
+                    column.width = maxLength + 2;
+                });
+            }
+            // Add filters to header row
+            if (options.addFilters && sheetData.data.length > 0) {
+                const lastColumn = sheetData.data[0].length;
+                const lastRow = sheetData.data.length;
+                worksheet.autoFilter = {
+                    from: { row: 1, column: 1 },
+                    to: { row: lastRow, column: lastColumn }
+                };
+            }
+            // Freeze header row
+            if (options.freezeHeader !== false && sheetData.data.length > 0) {
+                worksheet.views = [{ state: 'frozen', ySplit: 1 }];
+            }
+        }
+        // Write the file
+        await workbook.xlsx.writeFile(outputPath);
+    }
+    /**
+     * Creates a simple CSV file (fallback for .csv extension)
+     */
+    async createCSV(outputPath, sheet) {
+        const csv = sheet.data
+            .map(row => row
+            .map(cell => {
+            const str = String(cell ?? '');
+            // Escape quotes and wrap in quotes if contains comma, quote, or newline
+            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+                return `"${str.replace(/"/g, '""')}"`;
+            }
+            return str;
+        })
+            .join(','))
+            .join('\n');
+        await fs.writeFile(outputPath, csv, 'utf-8');
+    }
+    /**
+     * Read an existing Excel file and return sheet data
+     */
+    async read(inputPath) {
+        const workbook = new exceljs_1.default.Workbook();
+        await workbook.xlsx.readFile(inputPath);
+        const sheets = [];
+        workbook.eachSheet(worksheet => {
+            const data = [];
+            worksheet.eachRow((row, rowNumber) => {
+                const rowData = [];
+                row.eachCell({ includeEmpty: true }, (cell, colNumber) => {
+                    // Ensure array is long enough
+                    while (rowData.length < colNumber - 1) {
+                        rowData.push(null);
+                    }
+                    rowData.push(cell.value);
+                });
+                data.push(rowData);
+            });
+            sheets.push({
+                name: worksheet.name,
+                data,
+                hasHeader: true
+            });
+        });
+        return sheets;
+    }
+}
+exports.SpreadsheetBuilder = SpreadsheetBuilder;