squidclaw 2.1.0 → 2.2.0

package/lib/core/agent-tools-mixin.js

@@ -58,6 +58,8 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
       const fullResponse = result.messages.join('\n');
       toolRouter._currentContactId = contactId;
       toolRouter.storage = agent.storage;
+      toolRouter._currentContactId = contactId;
+      toolRouter._currentPlatform = metadata?.platform;
       const toolResult = await toolRouter.processResponse(fullResponse, agent.id);
 
       if (toolResult.toolUsed && toolResult.toolName === 'remind' && toolResult.reminderTime) {
@@ -71,6 +73,14 @@ export function addToolSupport(agent, toolRouter, knowledgeBase) {
         return result;
       }
 
+      // File attachment (pptx, etc)
+      if (toolResult.toolUsed && toolResult.filePath) {
+        result.filePath = toolResult.filePath;
+        result.fileName = toolResult.fileName;
+        result.messages = [toolResult.toolResult || 'Here\'s your file! 📎'];
+        return result;
+      }
+
       if (toolResult.toolUsed && (toolResult.imageBase64 || toolResult.imageUrl)) {
         // Image generated — pass through directly
         result.image = { base64: toolResult.imageBase64, url: toolResult.imageUrl, mimeType: toolResult.mimeType };

package/lib/middleware/ai-process.js

@@ -12,6 +12,8 @@ export async function aiProcessMiddleware(ctx, next) {
     messages: result.messages || [],
     reaction: result.reaction || null,
     image: result.image || null,
+    filePath: result.filePath || null,
+    fileName: result.fileName || null,
     _reminder: result._reminder || null,
   };
   ctx.metadata.originalType = ctx.metadata.originalType || null;

package/lib/middleware/response-sender.js

@@ -29,6 +29,27 @@ export async function responseSenderMiddleware(ctx, next) {
 
   // Send via appropriate channel
   if (ctx.platform === 'telegram' && tm) {
+    // Send file attachment (pptx, etc)
+    if (response.filePath) {
+      try {
+        const { readFileSync } = await import('fs');
+        const { InputFile } = await import('grammy');
+        const bot = tm.getBotForAgent?.(agentId) || tm.bots?.values()?.next()?.value;
+        if (bot) {
+          const buffer = readFileSync(response.filePath);
+          await bot.api.sendDocument(contactId.replace('tg_', ''), new InputFile(buffer, response.fileName || 'file'), {
+            caption: response.messages?.[0] || '',
+          });
+          // Skip normal message sending
+          await next();
+          return;
+        }
+      } catch (err) {
+        logger.error('sender', 'File send failed: ' + err.message);
+        // Fall through to text
+      }
+    }
+
     if (response.image) {
       const photoData = response.image.url ? { url: response.image.url } : { base64: response.image.base64 };
       await tm.sendPhoto(agentId, contactId, photoData, response.messages?.[0] || '', metadata);

package/lib/tools/pptx.js

@@ -0,0 +1,146 @@
+/**
+ * 🦑 PowerPoint Generator
+ * Create .pptx presentations from AI-generated content
+ */
+
+import { logger } from '../core/logger.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+export class PptxGenerator {
+  constructor() {
+    this.outputDir = '/tmp/squidclaw-pptx';
+    mkdirSync(this.outputDir, { recursive: true });
+  }
+
+  /**
+   * Create a presentation from structured content
+   * @param {string} title - Presentation title
+   * @param {Array} slides - [{title, content, bullets?, notes?}]
+   * @param {object} options - {theme, author}
+   */
+  async create(title, slides, options = {}) {
+    const pptxgen = (await import('pptxgenjs')).default;
+    const pres = new pptxgen();
+
+    // Metadata
+    pres.author = options.author || 'Squidclaw AI';
+    pres.title = title;
+    pres.subject = title;
+
+    // Theme colors
+    const themes = {
+      dark: { bg: '1a1a2e', title: 'e94560', text: 'eaeaea', accent: '0f3460' },
+      light: { bg: 'ffffff', title: '2d3436', text: '636e72', accent: '0984e3' },
+      blue: { bg: '0f3460', title: 'e94560', text: 'eaeaea', accent: '16213e' },
+      green: { bg: '1b4332', title: 'b7e4c7', text: 'd8f3dc', accent: '2d6a4f' },
+      corporate: { bg: 'ffffff', title: '2c3e50', text: '34495e', accent: '3498db' },
+      red: { bg: '2d0000', title: 'ff6b6b', text: 'ffe0e0', accent: '4a0000' },
+    };
+    const theme = themes[options.theme] || themes.corporate;
+
+    // Title slide
+    const titleSlide = pres.addSlide();
+    titleSlide.background = { color: theme.bg };
+    titleSlide.addText(title, {
+      x: 0.5, y: 1.5, w: 9, h: 1.5,
+      fontSize: 36, bold: true, color: theme.title,
+      align: 'center',
+    });
+    if (options.subtitle) {
+      titleSlide.addText(options.subtitle, {
+        x: 0.5, y: 3.2, w: 9, h: 0.8,
+        fontSize: 18, color: theme.text, align: 'center',
+      });
+    }
+    titleSlide.addText(new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }), {
+      x: 0.5, y: 4.5, w: 9, h: 0.5,
+      fontSize: 12, color: theme.text, align: 'center', italic: true,
+    });
+
+    // Content slides
+    for (const slide of slides) {
+      const s = pres.addSlide();
+      s.background = { color: theme.bg };
+
+      // Slide title
+      s.addText(slide.title || '', {
+        x: 0.5, y: 0.3, w: 9, h: 0.8,
+        fontSize: 24, bold: true, color: theme.title,
+      });
+
+      // Accent line
+      s.addShape(pres.ShapeType.rect, {
+        x: 0.5, y: 1.1, w: 2, h: 0.04, fill: { color: theme.title },
+      });
+
+      if (slide.bullets && slide.bullets.length > 0) {
+        // Bullet points
+        const bulletText = slide.bullets.map(b => ({
+          text: b,
+          options: { fontSize: 16, color: theme.text, bullet: { code: '2022' }, paraSpaceAfter: 8 },
+        }));
+        s.addText(bulletText, {
+          x: 0.5, y: 1.4, w: 9, h: 3.5,
+        });
+      } else if (slide.content) {
+        // Paragraph content
+        s.addText(slide.content, {
+          x: 0.5, y: 1.4, w: 9, h: 3.5,
+          fontSize: 16, color: theme.text,
+          valign: 'top', wrap: true,
+        });
+      }
+
+      // Slide notes
+      if (slide.notes) {
+        s.addNotes(slide.notes);
+      }
+
+      // Slide number
+      s.addText(String(slides.indexOf(slide) + 2), {
+        x: 9, y: 5, w: 0.5, h: 0.3,
+        fontSize: 10, color: theme.text, align: 'right',
+      });
+    }
+
+    // Save
+    const filename = title.replace(/[^a-zA-Z0-9\u0600-\u06FF ]/g, '').replace(/\s+/g, '_').slice(0, 50) + '.pptx';
+    const filepath = join(this.outputDir, filename);
+    
+    const data = await pres.write({ outputType: 'nodebuffer' });
+    writeFileSync(filepath, data);
+
+    logger.info('pptx', `Created: ${filepath} (${slides.length} slides)`);
+    return { filepath, filename, slideCount: slides.length + 1 }; // +1 for title slide
+  }
+
+  /**
+   * Parse AI-generated content into slides
+   * Format: "## Slide Title\n- bullet 1\n- bullet 2\n\n## Next Slide..."
+   */
+  static parseContent(text) {
+    const slides = [];
+    const sections = text.split(/^## /gm).filter(s => s.trim());
+
+    for (const section of sections) {
+      const lines = section.trim().split('\n');
+      const title = lines[0].trim();
+      const bullets = [];
+      let content = '';
+
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('- ') || line.startsWith('• ') || line.startsWith('* ')) {
+          bullets.push(line.replace(/^[-•*]\s*/, ''));
+        } else if (line) {
+          content += (content ? '\n' : '') + line;
+        }
+      }
+
+      slides.push({ title, bullets: bullets.length > 0 ? bullets : null, content: content || null });
+    }
+
+    return slides;
+  }
+}

package/lib/tools/router.js

@@ -59,6 +59,20 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    tools.push('', '### Create PowerPoint',
+      '---TOOL:pptx:Title of Presentation---',
+      'Create a .pptx PowerPoint file. After calling this, generate slides using markdown format:',
+      '## Slide Title',
+      '- Bullet point 1',
+      '- Bullet point 2',
+      '',
+      '## Another Slide',
+      '- More content',
+      '',
+      'Use ---TOOL:pptx_slides:## Slide 1\n- Point 1\n- Point 2\n\n## Slide 2\n- Point 3--- to generate the actual file.',
+      'Theme options after pipe: dark, light, blue, green, corporate, red',
+      'Example: ---TOOL:pptx_slides:title|theme|## Slide 1\n- point---');
+
     tools.push('', '### Allow User',
       '---TOOL:allow:user_id_or_phone---',
       'Add someone to the allowlist so they can message you.',
@@ -221,6 +235,56 @@ export class ToolRouter {
           }
           break;
         }
+        case 'pptx':
+        case 'pptx_slides':
+        case 'powerpoint':
+        case 'presentation': {
+          try {
+            const { PptxGenerator } = await import('./pptx.js');
+            const gen = new PptxGenerator();
+            
+            // Parse: title|theme|content or just content
+            const parts = toolArg.split('|');
+            let title, theme, slideContent;
+            
+            if (parts.length >= 3) {
+              title = parts[0].trim();
+              theme = parts[1].trim();
+              slideContent = parts.slice(2).join('|');
+            } else if (parts.length === 2) {
+              title = parts[0].trim();
+              slideContent = parts[1];
+              theme = 'corporate';
+            } else {
+              // Try to extract title from first ## heading
+              const firstH2 = toolArg.match(/^##\s+(.+)/m);
+              title = firstH2 ? firstH2[1] : 'Presentation';
+              slideContent = toolArg;
+              theme = 'corporate';
+            }
+            
+            const slides = PptxGenerator.parseContent(slideContent);
+            if (slides.length === 0) {
+              toolResult = 'No slides found. Use ## headings and - bullet points.';
+              break;
+            }
+            
+            const result = await gen.create(title, slides, { theme });
+            
+            // Return file path for sending
+            return {
+              toolUsed: true,
+              toolName: 'pptx',
+              toolResult: 'PowerPoint created: ' + result.filename + ' (' + result.slideCount + ' slides)',
+              filePath: result.filepath,
+              fileName: result.filename,
+              cleanResponse
+            };
+          } catch (err) {
+            toolResult = 'PowerPoint failed: ' + err.message;
+          }
+          break;
+        }
         case 'allow': {
           try {
             const { AllowlistManager } = await import('../features/allowlist-manager.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {
@@ -49,6 +49,7 @@
     "node-edge-tts": "^1.2.10",
     "pdfjs-dist": "^5.4.624",
     "pino": "^10.3.1",
+    "pptxgenjs": "^4.0.1",
     "puppeteer-core": "^24.37.5",
     "qrcode-terminal": "^0.12.0",
     "sharp": "^0.34.5",