squidclaw 2.1.0 → 2.3.0

package/lib/channels/telegram/bot.js

@@ -202,6 +202,18 @@ export class TelegramManager {
   /**
    * Send voice note
    */
+  async sendDocument(agentId, contactId, filePath, fileName, caption, metadata = {}) {
+    const botInfo = this.bots.get(agentId);
+    if (!botInfo?.bot) throw new Error('Bot not running');
+    const chatId = contactId.replace('tg_', '');
+    const { readFileSync } = await import('fs');
+    const buffer = readFileSync(filePath);
+    await botInfo.bot.api.sendDocument(chatId, new InputFile(buffer, fileName || 'file'), {
+      caption: caption || '',
+    });
+    logger.info('telegram', 'Sent document: ' + fileName);
+  }
+
   async sendVoiceNote(agentId, contactId, audioBuffer, metadata = {}) {
     const botInfo = this.bots.get(agentId);
     if (!botInfo?.bot) return;

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/commands.js

@@ -39,27 +39,32 @@ export async function commandsMiddleware(ctx, next) {
 
   if (cmd === '/status' || textCmd === 'status') {
     const uptime = process.uptime();
-    const h = Math.floor(uptime / 3600);
+    const d = Math.floor(uptime / 86400);
+    const h = Math.floor((uptime % 86400) / 3600);
     const m = Math.floor((uptime % 3600) / 60);
+    const uptimeStr = d > 0 ? d + 'd ' + h + 'h' : h + 'h ' + m + 'm';
     const usage = await ctx.storage.getUsage(ctx.agentId) || {};
     const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
-    const fmtT = tokens >= 1e6 ? (tokens/1e6).toFixed(1)+'M' : tokens >= 1e3 ? (tokens/1e3).toFixed(1)+'K' : String(tokens);
+    const fmtT = (n) => n >= 1e6 ? (n/1e6).toFixed(1)+'M' : n >= 1e3 ? (n/1e3).toFixed(1)+'K' : String(n || 0);
     const waOn = Object.values(ctx.engine.whatsappManager?.getStatuses() || {}).some(s => s.connected);
+    const memCount = ctx.storage.db.prepare('SELECT COUNT(*) as c FROM memories WHERE agent_id = ?').get(ctx.agentId)?.c || 0;
+    const convCount = ctx.storage.db.prepare('SELECT COUNT(*) as c FROM conversations WHERE agent_id = ?').get(ctx.agentId)?.c || 0;
+    const reminderCount = ctx.storage.db.prepare("SELECT COUNT(*) as c FROM reminders WHERE agent_id = ? AND fired = 0").get(ctx.agentId)?.c || 0;
+    const ram = (process.memoryUsage().rss / 1024 / 1024).toFixed(0);
 
     await ctx.reply([
-      `🦑 *${ctx.agent?.name || ctx.agentId} Status*`,
-      '────────────────────',
-      `🧠 Model: ${ctx.agent?.model || 'unknown'}`,
-      `⏱️ Uptime: ${h}h ${m}m`,
-      `💬 Messages: ${usage.messages || 0}`,
-      `🪙 Tokens: ${fmtT}`,
-      `💰 Cost: $${(usage.cost_usd || 0).toFixed(4)}`,
-      '────────────────────',
-      `📱 WhatsApp: ${waOn ? '✅' : '❌'}`,
-      `✈️ Telegram: ${ctx.engine.telegramManager ? '✅' : '❌'}`,
-      '────────────────────',
-      `⚡ Skills: 20+`,
-      `🗣️ Language: ${ctx.agent?.language || 'bilingual'}`,
+      '🦑 *Squidclaw v2.2.0*',
+      '*' + (ctx.agent?.name || 'Agent') + '* — Status',
+      '🧠 Model: ' + (ctx.agent?.model || '?'),
+      '⚡ Pipeline: 14 middleware · 40+ skills',
+      '🗣️ Language: Bilingual (AR/EN)',
+      '💬 Messages: ' + convCount,
+      '🪙 Tokens: ' + fmtT(tokens) + ' (↑' + fmtT(usage.input_tokens || 0) + ' ↓' + fmtT(usage.output_tokens || 0) + ')',
+      '💰 Cost: $' + (usage.cost_usd || 0).toFixed(4),
+      '✈️ Telegram: ' + (ctx.engine.telegramManager ? '🟢' : '🔴') + ' · WhatsApp: ' + (waOn ? '🟢' : '🔴'),
+      '💾 Memories: ' + memCount + ' · Reminders: ' + reminderCount,
+      '⏱️ Uptime: ' + uptimeStr + ' · RAM: ' + ram + 'MB',
+      '💚 Heartbeat: active',
     ].join('\n'));
     return;
   }
@@ -132,6 +137,14 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/reset' || cmd === '/restart') {
+    await ctx.reply('🔄 Restarting Squidclaw...');
+    setTimeout(() => {
+      process.exit(0); // Process manager (pm2/systemd) will restart it
+    }, 1000);
+    return;
+  }
+
   if (cmd === '/allow') {
     const args = msg.slice(7).trim();
     if (!args) { await ctx.reply('Usage: /allow <user_id or phone>'); return; }

package/lib/middleware/response-sender.js

@@ -29,6 +29,18 @@ export async function responseSenderMiddleware(ctx, next) {
 
   // Send via appropriate channel
   if (ctx.platform === 'telegram' && tm) {
+    // Send file attachment (pptx, etc)
+    if (response.filePath) {
+      try {
+        await tm.sendDocument(agentId, contactId, response.filePath, response.fileName, response.messages?.[0] || '');
+        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,744 @@
+/**
+ * 🦑 PowerPoint Generator PRO
+ * Full-featured .pptx with charts, images, tables, layouts
+ */
+
+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 });
+  }
+
+  // ── THEMES ──
+  static THEMES = {
+    dark:       { bg: '0d1117', bg2: '161b22', title: 'e6edf3', text: 'b1bac4', accent: '58a6ff', accent2: '3fb950', accent3: 'bc8cff', border: '30363d' },
+    light:      { bg: 'ffffff', bg2: 'f6f8fa', title: '1f2328', text: '656d76', accent: '0969da', accent2: '1a7f37', accent3: '8250df', border: 'd0d7de' },
+    blue:       { bg: '0a1628', bg2: '0f2440', title: 'ffffff', text: 'a3c4e8', accent: '4da6ff', accent2: '00d4aa', accent3: 'ff6b9d', border: '1e3a5f' },
+    green:      { bg: '0d1f0d', bg2: '132a13', title: 'ffffff', text: 'a7d7a7', accent: '4ade80', accent2: 'facc15', accent3: 'fb923c', border: '1a3d1a' },
+    corporate:  { bg: 'ffffff', bg2: 'f1f5f9', title: '0f172a', text: '475569', accent: '2563eb', accent2: '059669', accent3: 'dc2626', border: 'e2e8f0' },
+    red:        { bg: '1a0000', bg2: '2d0a0a', title: 'ffffff', text: 'fca5a5', accent: 'ef4444', accent2: 'f59e0b', accent3: '8b5cf6', border: '450a0a' },
+    gradient:   { bg: '0c0c1d', bg2: '1a1a3e', title: 'ffffff', text: 'c4b5fd', accent: '818cf8', accent2: 'f472b6', accent3: '34d399', border: '312e81' },
+    minimal:    { bg: 'fafafa', bg2: 'f0f0f0', title: '111111', text: '555555', accent: '111111', accent2: '888888', accent3: 'bbbbbb', border: 'dddddd' },
+    saudi:      { bg: '003c1f', bg2: '004d28', title: 'ffffff', text: 'c8e6c9', accent: '4caf50', accent2: 'ffd54f', accent3: 'ffffff', border: '1b5e20' },
+    ocean:      { bg: '0a192f', bg2: '112240', title: 'ccd6f6', text: '8892b0', accent: '64ffda', accent2: 'ffd700', accent3: 'ff6b6b', border: '233554' },
+  };
+
+  /**
+   * Create a full presentation
+   */
+  async create(title, slides, options = {}) {
+    const pptxgen = (await import('pptxgenjs')).default;
+    const pres = new pptxgen();
+
+    pres.author = options.author || 'Squidclaw AI 🦑';
+    pres.title = title;
+    pres.subject = options.subtitle || title;
+    pres.layout = 'LAYOUT_WIDE'; // 16:9
+
+    const theme = PptxGenerator.THEMES[options.theme] || PptxGenerator.THEMES.corporate;
+
+    // ── TITLE SLIDE ──
+    this._addTitleSlide(pres, title, options, theme);
+
+    // ── CONTENT SLIDES ──
+    for (let i = 0; i < slides.length; i++) {
+      const slide = slides[i];
+      const slideNum = i + 2;
+      const totalSlides = slides.length + 1;
+
+      switch (slide.type) {
+        case 'chart':
+          this._addChartSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'table':
+          this._addTableSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'comparison':
+          this._addComparisonSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'timeline':
+          this._addTimelineSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'stats':
+          this._addStatsSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'quote':
+          this._addQuoteSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'image':
+          this._addImageSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        case 'section':
+          this._addSectionSlide(pres, slide, theme, slideNum, totalSlides);
+          break;
+        default:
+          this._addContentSlide(pres, slide, theme, slideNum, totalSlides);
+      }
+    }
+
+    // ── THANK YOU SLIDE ──
+    if (options.thankYou !== false) {
+      this._addThankYouSlide(pres, options, theme);
+    }
+
+    // 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 PRO: ${filepath} (${slides.length + 2} slides)`);
+    return { filepath, filename, slideCount: slides.length + 2 };
+  }
+
+  // ── SLIDE BUILDERS ──
+
+  _addBase(pres, theme, slideNum, totalSlides) {
+    const s = pres.addSlide();
+    s.background = { color: theme.bg };
+
+    // Top accent bar
+    s.addShape(pres.ShapeType.rect, {
+      x: 0, y: 0, w: '100%', h: 0.06, fill: { color: theme.accent },
+    });
+
+    // Footer
+    if (slideNum && totalSlides) {
+      s.addText(slideNum + ' / ' + totalSlides, {
+        x: 11.5, y: 7.1, w: 1.5, h: 0.3,
+        fontSize: 9, color: theme.text, align: 'right', italic: true,
+      });
+      s.addText('Squidclaw AI 🦑', {
+        x: 0.3, y: 7.1, w: 2, h: 0.3,
+        fontSize: 9, color: theme.border,
+      });
+    }
+    return s;
+  }
+
+  _addTitleSlide(pres, title, options, theme) {
+    const s = pres.addSlide();
+    s.background = { color: theme.bg };
+
+    // Large accent shape
+    s.addShape(pres.ShapeType.rect, {
+      x: 0, y: 0, w: '100%', h: 0.08, fill: { color: theme.accent },
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 5.5, w: 3, h: 0.05, fill: { color: theme.accent },
+    });
+
+    // Title
+    s.addText(title, {
+      x: 0.5, y: 1.8, w: 12, h: 1.5,
+      fontSize: 42, bold: true, color: theme.title,
+      fontFace: 'Arial',
+    });
+
+    // Subtitle
+    if (options.subtitle) {
+      s.addText(options.subtitle, {
+        x: 0.5, y: 3.4, w: 10, h: 0.8,
+        fontSize: 20, color: theme.text, fontFace: 'Arial',
+      });
+    }
+
+    // Date + author
+    const date = new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
+    s.addText((options.author || '') + (options.author ? '  •  ' : '') + date, {
+      x: 0.5, y: 5.8, w: 8, h: 0.5,
+      fontSize: 14, color: theme.accent, fontFace: 'Arial',
+    });
+  }
+
+  _addContentSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    // Title
+    s.addText(slide.title || '', {
+      x: 0.5, y: 0.3, w: 12, h: 0.8,
+      fontSize: 28, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+
+    // Accent line under title
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.15, w: 2.5, h: 0.04, fill: { color: theme.accent },
+    });
+
+    if (slide.bullets && slide.bullets.length > 0) {
+      const rows = slide.bullets.map(b => ({
+        text: b,
+        options: {
+          fontSize: 18, color: theme.text, fontFace: 'Arial',
+          bullet: { type: 'bullet', style: '●', color: theme.accent },
+          paraSpaceAfter: 10, paraSpaceBefore: 4,
+          indentLevel: 0,
+        },
+      }));
+
+      s.addText(rows, { x: 0.7, y: 1.5, w: 11.5, h: 5 });
+    }
+
+    if (slide.content) {
+      s.addText(slide.content, {
+        x: 0.5, y: 1.5, w: 12, h: 5,
+        fontSize: 18, color: theme.text, fontFace: 'Arial',
+        valign: 'top', wrap: true, lineSpacing: 28,
+      });
+    }
+  }
+
+  _addChartSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    s.addText(slide.title || 'Chart', {
+      x: 0.5, y: 0.3, w: 12, h: 0.7,
+      fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.05, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    const chartType = slide.chartType || 'bar';
+    const chartTypes = {
+      bar: pres.ChartType.bar,
+      line: pres.ChartType.line,
+      pie: pres.ChartType.pie,
+      doughnut: pres.ChartType.doughnut,
+      area: pres.ChartType.area,
+      bar3d: pres.ChartType.bar3D,
+    };
+
+    const type = chartTypes[chartType] || pres.ChartType.bar;
+    const colors = [theme.accent, theme.accent2, theme.accent3, theme.text, theme.border];
+
+    const chartData = slide.chartData || [
+      { name: 'Series 1', labels: ['A', 'B', 'C', 'D'], values: [10, 20, 30, 40] }
+    ];
+
+    s.addChart(type, chartData, {
+      x: 0.8, y: 1.4, w: 11.5, h: 5.2,
+      showTitle: false,
+      showValue: slide.showValues !== false,
+      catAxisLabelColor: theme.text,
+      valAxisLabelColor: theme.text,
+      chartColors: colors,
+      legendColor: theme.text,
+      showLegend: chartData.length > 1,
+      legendPos: 'b',
+      dataLabelColor: theme.title,
+      dataLabelFontSize: 10,
+      valGridLine: { color: theme.border, size: 0.5 },
+    });
+  }
+
+  _addTableSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    s.addText(slide.title || 'Table', {
+      x: 0.5, y: 0.3, w: 12, h: 0.7,
+      fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.05, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    const rows = slide.tableData || [['Header 1', 'Header 2'], ['Data 1', 'Data 2']];
+    const tableRows = rows.map((row, ri) =>
+      row.map(cell => ({
+        text: String(cell),
+        options: {
+          fontSize: ri === 0 ? 14 : 13,
+          bold: ri === 0,
+          color: ri === 0 ? 'ffffff' : theme.text,
+          fill: { color: ri === 0 ? theme.accent : (ri % 2 === 0 ? theme.bg2 : theme.bg) },
+          border: [{ color: theme.border, pt: 0.5 }],
+          align: 'left',
+          valign: 'middle',
+          fontFace: 'Arial',
+        },
+      }))
+    );
+
+    const colW = 11.5 / (rows[0]?.length || 2);
+    s.addTable(tableRows, {
+      x: 0.5, y: 1.4, w: 12, h: 0.5,
+      colW: Array(rows[0]?.length || 2).fill(colW),
+      rowH: rows.map((_, i) => i === 0 ? 0.5 : 0.45),
+      margin: [5, 8, 5, 8],
+    });
+  }
+
+  _addComparisonSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    s.addText(slide.title || 'Comparison', {
+      x: 0.5, y: 0.3, w: 12, h: 0.7,
+      fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.05, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    const left = slide.left || { title: 'Option A', points: ['Point 1'] };
+    const right = slide.right || { title: 'Option B', points: ['Point 1'] };
+
+    // Left column
+    s.addShape(pres.ShapeType.roundRect, {
+      x: 0.5, y: 1.4, w: 5.8, h: 5.2,
+      fill: { color: theme.bg2 }, rectRadius: 0.15,
+      line: { color: theme.accent, width: 1.5 },
+    });
+    s.addText(left.title, {
+      x: 0.8, y: 1.6, w: 5.2, h: 0.6,
+      fontSize: 20, bold: true, color: theme.accent, fontFace: 'Arial',
+    });
+    if (left.points) {
+      const lpts = left.points.map(p => ({
+        text: p,
+        options: { fontSize: 15, color: theme.text, bullet: { code: '2022', color: theme.accent }, paraSpaceAfter: 8 },
+      }));
+      s.addText(lpts, { x: 1, y: 2.3, w: 4.8, h: 4 });
+    }
+
+    // VS
+    s.addText('VS', {
+      x: 5.8, y: 3.5, w: 1.4, h: 0.6,
+      fontSize: 18, bold: true, color: theme.accent, align: 'center',
+    });
+
+    // Right column
+    s.addShape(pres.ShapeType.roundRect, {
+      x: 6.7, y: 1.4, w: 5.8, h: 5.2,
+      fill: { color: theme.bg2 }, rectRadius: 0.15,
+      line: { color: theme.accent2, width: 1.5 },
+    });
+    s.addText(right.title, {
+      x: 7, y: 1.6, w: 5.2, h: 0.6,
+      fontSize: 20, bold: true, color: theme.accent2, fontFace: 'Arial',
+    });
+    if (right.points) {
+      const rpts = right.points.map(p => ({
+        text: p,
+        options: { fontSize: 15, color: theme.text, bullet: { code: '2022', color: theme.accent2 }, paraSpaceAfter: 8 },
+      }));
+      s.addText(rpts, { x: 7.2, y: 2.3, w: 4.8, h: 4 });
+    }
+  }
+
+  _addTimelineSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    s.addText(slide.title || 'Timeline', {
+      x: 0.5, y: 0.3, w: 12, h: 0.7,
+      fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.05, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    const events = slide.events || [{ date: '2024', text: 'Event 1' }];
+    const count = Math.min(events.length, 6);
+    const totalW = 11.5;
+    const spacing = totalW / count;
+
+    // Timeline line
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 3.5, w: totalW, h: 0.04, fill: { color: theme.accent },
+    });
+
+    events.slice(0, 6).forEach((ev, i) => {
+      const x = 0.5 + (i * spacing) + (spacing / 2) - 0.8;
+      const above = i % 2 === 0;
+
+      // Circle
+      s.addShape(pres.ShapeType.ellipse, {
+        x: x + 0.55, y: 3.3, w: 0.4, h: 0.4,
+        fill: { color: theme.accent },
+      });
+
+      // Date
+      s.addText(ev.date || '', {
+        x: x, y: above ? 2.2 : 3.9, w: 1.6, h: 0.4,
+        fontSize: 13, bold: true, color: theme.accent, align: 'center', fontFace: 'Arial',
+      });
+
+      // Text
+      s.addText(ev.text || '', {
+        x: x - 0.2, y: above ? 2.6 : 4.3, w: 2, h: 0.8,
+        fontSize: 11, color: theme.text, align: 'center', fontFace: 'Arial', wrap: true,
+      });
+    });
+  }
+
+  _addStatsSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    s.addText(slide.title || 'Key Metrics', {
+      x: 0.5, y: 0.3, w: 12, h: 0.7,
+      fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 1.05, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    const stats = slide.stats || [{ value: '100', label: 'Stat' }];
+    const count = Math.min(stats.length, 4);
+    const cardW = 2.5;
+    const gap = (12 - (count * cardW)) / (count + 1);
+    const colors = [theme.accent, theme.accent2, theme.accent3, theme.text];
+
+    stats.slice(0, 4).forEach((stat, i) => {
+      const x = gap + i * (cardW + gap);
+
+      // Card bg
+      s.addShape(pres.ShapeType.roundRect, {
+        x, y: 2, w: cardW, h: 3.5,
+        fill: { color: theme.bg2 }, rectRadius: 0.15,
+        line: { color: colors[i], width: 1.5 },
+      });
+
+      // Icon/emoji
+      if (stat.icon) {
+        s.addText(stat.icon, {
+          x, y: 2.3, w: cardW, h: 0.8,
+          fontSize: 32, align: 'center',
+        });
+      }
+
+      // Big number
+      s.addText(stat.value || '0', {
+        x, y: stat.icon ? 3 : 2.5, w: cardW, h: 1.2,
+        fontSize: 40, bold: true, color: colors[i], align: 'center', fontFace: 'Arial',
+      });
+
+      // Label
+      s.addText(stat.label || '', {
+        x, y: stat.icon ? 4.1 : 3.7, w: cardW, h: 0.8,
+        fontSize: 14, color: theme.text, align: 'center', fontFace: 'Arial', wrap: true,
+      });
+
+      // Sub text
+      if (stat.sub) {
+        s.addText(stat.sub, {
+          x, y: stat.icon ? 4.7 : 4.3, w: cardW, h: 0.5,
+          fontSize: 11, color: theme.border, align: 'center', fontFace: 'Arial', italic: true,
+        });
+      }
+    });
+  }
+
+  _addQuoteSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    // Large quote mark
+    s.addText('"', {
+      x: 1, y: 1.2, w: 2, h: 2,
+      fontSize: 120, color: theme.accent, fontFace: 'Georgia', bold: true,
+    });
+
+    // Quote text
+    s.addText(slide.quote || slide.content || '', {
+      x: 1.5, y: 2.5, w: 10, h: 2.5,
+      fontSize: 28, color: theme.title, fontFace: 'Georgia', italic: true,
+      lineSpacing: 36, wrap: true,
+    });
+
+    // Attribution
+    if (slide.author || slide.attribution) {
+      s.addShape(pres.ShapeType.rect, {
+        x: 1.5, y: 5.2, w: 1.5, h: 0.03, fill: { color: theme.accent },
+      });
+      s.addText('— ' + (slide.author || slide.attribution), {
+        x: 1.5, y: 5.4, w: 8, h: 0.5,
+        fontSize: 16, color: theme.accent, fontFace: 'Arial',
+      });
+    }
+  }
+
+  _addImageSlide(pres, slide, theme, slideNum, total) {
+    const s = this._addBase(pres, theme, slideNum, total);
+
+    if (slide.title) {
+      s.addText(slide.title, {
+        x: 0.5, y: 0.3, w: 12, h: 0.7,
+        fontSize: 26, bold: true, color: theme.title, fontFace: 'Arial',
+      });
+    }
+
+    if (slide.imageUrl) {
+      try {
+        s.addImage({
+          path: slide.imageUrl,
+          x: 1, y: 1.5, w: 11, h: 5,
+          sizing: { type: 'contain', w: 11, h: 5 },
+        });
+      } catch {}
+    }
+
+    if (slide.caption) {
+      s.addText(slide.caption, {
+        x: 0.5, y: 6.5, w: 12, h: 0.5,
+        fontSize: 12, color: theme.text, align: 'center', italic: true,
+      });
+    }
+  }
+
+  _addSectionSlide(pres, slide, theme, slideNum, total) {
+    const s = pres.addSlide();
+    s.background = { color: theme.bg2 };
+
+    s.addShape(pres.ShapeType.rect, {
+      x: 0, y: 0, w: '100%', h: 0.08, fill: { color: theme.accent },
+    });
+
+    s.addText(slide.title || 'Section', {
+      x: 0.5, y: 2.5, w: 12, h: 1.5,
+      fontSize: 38, bold: true, color: theme.title, fontFace: 'Arial',
+    });
+
+    if (slide.subtitle) {
+      s.addText(slide.subtitle, {
+        x: 0.5, y: 4, w: 10, h: 0.8,
+        fontSize: 18, color: theme.text, fontFace: 'Arial',
+      });
+    }
+
+    s.addShape(pres.ShapeType.rect, {
+      x: 0.5, y: 4.9, w: 2.5, h: 0.04, fill: { color: theme.accent },
+    });
+  }
+
+  _addThankYouSlide(pres, options, theme) {
+    const s = pres.addSlide();
+    s.background = { color: theme.bg };
+
+    s.addShape(pres.ShapeType.rect, {
+      x: 0, y: 0, w: '100%', h: 0.08, fill: { color: theme.accent },
+    });
+
+    s.addText('Thank You', {
+      x: 0, y: 2, w: 13, h: 1.5,
+      fontSize: 48, bold: true, color: theme.title, align: 'center', fontFace: 'Arial',
+    });
+
+    s.addShape(pres.ShapeType.rect, {
+      x: 5.5, y: 3.6, w: 2, h: 0.04, fill: { color: theme.accent },
+    });
+
+    if (options.contact) {
+      s.addText(options.contact, {
+        x: 0, y: 4, w: 13, h: 0.8,
+        fontSize: 16, color: theme.text, align: 'center', fontFace: 'Arial',
+      });
+    }
+
+    s.addText('Created with Squidclaw AI 🦑', {
+      x: 0, y: 6.5, w: 13, h: 0.5,
+      fontSize: 11, color: theme.border, align: 'center', italic: true,
+    });
+  }
+
+  // ── PARSER ──
+
+  /**
+   * Parse AI content into structured slides
+   * Supports: ## Title, - bullets, [chart:bar], [table], [stats], [timeline], [quote], [compare], [section]
+   */
+  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 titleLine = lines[0].trim();
+      
+      // Detect slide type from markers
+      let slide = { title: titleLine, type: 'content', bullets: [], content: '' };
+
+      // [chart:bar] or [chart:pie] etc
+      const chartMatch = titleLine.match(/\[chart:(\w+)\]/i) || lines.some(l => l.match(/\[chart:(\w+)\]/i));
+      if (chartMatch || lines.some(l => /\[chart/i.test(l))) {
+        slide.type = 'chart';
+        slide.title = titleLine.replace(/\[chart:\w+\]/i, '').trim();
+        const typeMatch = section.match(/\[chart:(\w+)\]/i);
+        slide.chartType = typeMatch ? typeMatch[1] : 'bar';
+        slide.chartData = this._parseChartData(lines.slice(1));
+        slides.push(slide);
+        continue;
+      }
+
+      // [table]
+      if (lines.some(l => /\[table\]|^\|/.test(l))) {
+        slide.type = 'table';
+        slide.title = titleLine.replace(/\[table\]/i, '').trim();
+        slide.tableData = this._parseTableData(lines.slice(1));
+        slides.push(slide);
+        continue;
+      }
+
+      // [stats]
+      if (lines.some(l => /\[stats?\]/i.test(l))) {
+        slide.type = 'stats';
+        slide.title = titleLine.replace(/\[stats?\]/i, '').trim();
+        slide.stats = this._parseStats(lines.slice(1));
+        slides.push(slide);
+        continue;
+      }
+
+      // [timeline]
+      if (lines.some(l => /\[timeline\]/i.test(l))) {
+        slide.type = 'timeline';
+        slide.title = titleLine.replace(/\[timeline\]/i, '').trim();
+        slide.events = this._parseTimeline(lines.slice(1));
+        slides.push(slide);
+        continue;
+      }
+
+      // [quote]
+      if (lines.some(l => /\[quote\]/i.test(l)) || titleLine.includes('[quote]')) {
+        slide.type = 'quote';
+        slide.title = titleLine.replace(/\[quote\]/i, '').trim();
+        const quoteLines = lines.slice(1).filter(l => !l.includes('[quote]'));
+        const authorLine = quoteLines.find(l => l.startsWith('—') || l.startsWith('-—') || l.startsWith('- Author:'));
+        slide.quote = quoteLines.filter(l => l !== authorLine).map(l => l.replace(/^[-•*]\s*/, '').trim()).filter(Boolean).join(' ');
+        slide.author = authorLine ? authorLine.replace(/^[-—•*\s]*Author:\s*|^[-—]\s*/i, '').trim() : '';
+        slides.push(slide);
+        continue;
+      }
+
+      // [compare] or [vs]
+      if (lines.some(l => /\[compare\]|\[vs\]/i.test(l))) {
+        slide.type = 'comparison';
+        slide.title = titleLine.replace(/\[compare\]|\[vs\]/i, '').trim();
+        const parsed = this._parseComparison(lines.slice(1));
+        slide.left = parsed.left;
+        slide.right = parsed.right;
+        slides.push(slide);
+        continue;
+      }
+
+      // [section]
+      if (titleLine.includes('[section]') || lines.some(l => /\[section\]/i.test(l))) {
+        slide.type = 'section';
+        slide.title = titleLine.replace(/\[section\]/i, '').trim();
+        slide.subtitle = lines.slice(1).filter(l => !l.includes('[section]')).map(l => l.trim()).filter(Boolean).join(' ');
+        slides.push(slide);
+        continue;
+      }
+
+      // Default: bullets
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('- ') || line.startsWith('• ') || line.startsWith('* ')) {
+          slide.bullets.push(line.replace(/^[-•*]\s*/, ''));
+        } else if (line) {
+          slide.content += (slide.content ? '\n' : '') + line;
+        }
+      }
+      if (!slide.bullets.length && slide.content) slide.bullets = null;
+      slides.push(slide);
+    }
+
+    return slides;
+  }
+
+  static _parseChartData(lines) {
+    const data = [];
+    let current = null;
+    const labels = [];
+    const values = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.includes('[chart')) continue;
+
+      // Format: "Label: value" or "Label | value"
+      const match = trimmed.match(/^[-•*]?\s*(.+?)[\s:|\-→]+(\d+[\d,.]*%?)\s*$/);
+      if (match) {
+        labels.push(match[1].trim());
+        values.push(parseFloat(match[2].replace(/[,%]/g, '')));
+      }
+    }
+
+    if (labels.length > 0) {
+      data.push({ name: 'Data', labels, values });
+    }
+    return data.length > 0 ? data : [{ name: 'Sample', labels: ['A', 'B', 'C'], values: [30, 50, 20] }];
+  }
+
+  static _parseTableData(lines) {
+    const rows = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.includes('[table]') || /^[-|:]+$/.test(trimmed)) continue;
+      if (trimmed.startsWith('|')) {
+        const cells = trimmed.split('|').filter(c => c.trim()).map(c => c.trim());
+        if (cells.length > 0) rows.push(cells);
+      } else if (trimmed.includes(',') || trimmed.includes('\t')) {
+        rows.push(trimmed.split(/[,\t]+/).map(c => c.trim()));
+      }
+    }
+    return rows.length > 0 ? rows : [['Col 1', 'Col 2'], ['Data', 'Data']];
+  }
+
+  static _parseStats(lines) {
+    const stats = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.includes('[stat')) continue;
+      // Format: "📊 100M+ — Active users" or "100M: Active users"
+      const match = trimmed.match(/^[-•*]?\s*([^\w]*?)?\s*([\d,.]+[%KMBkm+]*)\s*[-:—|]+\s*(.+)/);
+      if (match) {
+        stats.push({
+          icon: match[1]?.trim() || undefined,
+          value: match[2].trim(),
+          label: match[3].trim(),
+        });
+      }
+    }
+    return stats.length > 0 ? stats : [{ value: '?', label: 'No data' }];
+  }
+
+  static _parseTimeline(lines) {
+    const events = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.includes('[timeline]')) continue;
+      const match = trimmed.match(/^[-•*]?\s*(\d{4}[s]?|Phase \d+|Q\d|Step \d+)\s*[-:—|]+\s*(.+)/i);
+      if (match) {
+        events.push({ date: match[1].trim(), text: match[2].trim() });
+      }
+    }
+    return events.length > 0 ? events : [{ date: '???', text: 'No events' }];
+  }
+
+  static _parseComparison(lines) {
+    const left = { title: 'Option A', points: [] };
+    const right = { title: 'Option B', points: [] };
+    let side = 'left';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.includes('[compare]') || trimmed.includes('[vs]')) continue;
+
+      if (trimmed.toLowerCase().includes('vs') || trimmed === '---') {
+        side = 'right';
+        continue;
+      }
+
+      const target = side === 'left' ? left : right;
+      if (trimmed.startsWith('###') || trimmed.startsWith('**')) {
+        target.title = trimmed.replace(/^[#*\s]+|[*]+$/g, '');
+      } else if (trimmed.startsWith('- ') || trimmed.startsWith('• ')) {
+        target.points.push(trimmed.replace(/^[-•]\s*/, ''));
+      }
+    }
+
+    return { left, right };
+  }
+}

package/lib/tools/router.js

@@ -23,7 +23,9 @@ export class ToolRouter {
   getToolDescriptions() {
     const tools = [
       '## Available Tools',
-      'You can use tools by including special tags in your response:',
+      'You can use tools by including special tags in your response.',
+      'IMPORTANT: You CAN send files, images, voice notes, and documents in this chat. The system handles delivery automatically.',
+      'When asked to create files (PowerPoint, etc), USE THE TOOL — do NOT say you cannot send files.',
       '',
       '### Web Search',
       '---TOOL:search:your search query---',
@@ -59,6 +61,24 @@ export class ToolRouter {
         'Send an email.');
     }
 
+    tools.push('', '### Create PowerPoint (SENDS AS FILE IN CHAT!)',
+      '---TOOL:pptx_slides:Title|theme|slides content---',
+      'Creates a .pptx file and SENDS IT directly. You MUST use this when asked for PPT/presentation.',
+      'Format: title|theme|slides. Themes: dark, light, blue, green, corporate, red, gradient, minimal, saudi, ocean.',
+      '',
+      'SLIDE TYPES (use tags in ## title):',
+      '- Normal: ## Title then - bullet points',
+      '- Chart: ## Revenue [chart:bar] then - Label: value (types: bar, pie, line, doughnut, area)',
+      '- Table: ## Data [table] then | Col1 | Col2 | rows',
+      '- Stats: ## Metrics [stats] then - 📊 100M — Active users',
+      '- Timeline: ## History [timeline] then - 2020: Event happened',
+      '- Quote: ## [quote] then quote text then — Author Name',
+      '- Compare: ## Comparison [compare] then left items, ---, right items',
+      '- Section: ## New Section [section]',
+      '',
+      'Example:',
+      '---TOOL:pptx_slides:AI Report|dark|## Introduction\n- AI is transforming industries\n- Revenue growing 40% YoY\n\n## Growth [chart:bar]\n- 2020: 50\n- 2021: 80\n- 2022: 120\n- 2023: 200\n\n## Key Stats [stats]\n- 🌍 195 — Countries using AI\n- 💰 $500B — Market size\n- 🚀 40% — Annual growth---');
+
     tools.push('', '### Allow User',
       '---TOOL:allow:user_id_or_phone---',
       'Add someone to the allowlist so they can message you.',
@@ -221,6 +241,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.3.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",