opencode-pollinations-plugin 6.1.0-beta.1 → 6.1.0-beta.10

package/dist/server/quota.js

@@ -1,12 +1,17 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import * as https from 'https'; // Use Native HTTPS
+import * as crypto from 'crypto';
 import { loadConfig } from './config.js';
-// === CACHE ===
+// === CACHE & CONSTANTS ===
 const CACHE_TTL = 30000; // 30 secondes
 let cachedQuota = null;
 let lastQuotaFetch = 0;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const HISTORY_RETENTION_MS = 48 * 60 * 60 * 1000; // 48h history
 // === TIER LIMITS ===
 const TIER_LIMITS = {
+    microbe: { pollen: 0.1, emoji: '🦠' },
     spore: { pollen: 1, emoji: '🦠' },
     seed: { pollen: 3, emoji: '🌱' },
     flower: { pollen: 10, emoji: '🌸' },
@@ -19,24 +24,71 @@ function logQuota(msg) {
     }
     catch (e) { }
 }
-// === FONCTIONS PRINCIPALES ===
+// === HISTORY MANAGER (JSON) ===
+function getHistoryFilePath() {
+    const homedir = process.env.HOME || '/tmp';
+    const historyDir = path.join(homedir, '.pollinations');
+    if (!fs.existsSync(historyDir)) {
+        try {
+            fs.mkdirSync(historyDir, { recursive: true });
+        }
+        catch (e) { }
+    }
+    return path.join(historyDir, 'usage_history.json');
+}
+function computeEntrySignature(entry) {
+    // Unique signature per transaction: timestamp + model + cost + source
+    return crypto.createHash('md5').update(`${entry.timestamp}|${entry.model}|${entry.cost_usd}|${entry.meter_source}`).digest('hex');
+}
+function updateLocalHistory(newEntries) {
+    const filePath = getHistoryFilePath();
+    let history = [];
+    // 1. Load existing
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            history = JSON.parse(raw);
+        }
+    }
+    catch (e) {
+        logQuota(`Failed to load history: ${e}`);
+        history = [];
+    }
+    // 2. Merge (Deduplication via Signature)
+    const existingSignatures = new Set(history.map(computeEntrySignature));
+    let addedCount = 0;
+    for (const entry of newEntries) {
+        const sig = computeEntrySignature(entry);
+        if (!existingSignatures.has(sig)) {
+            history.push(entry);
+            existingSignatures.add(sig);
+            addedCount++;
+        }
+    }
+    // 3. Prune (> 48h)
+    const now = Date.now();
+    const beforePrune = history.length;
+    history = history.filter(e => {
+        const entryTime = new Date(e.timestamp.replace(' ', 'T') + 'Z').getTime();
+        return (now - entryTime) < HISTORY_RETENTION_MS;
+    });
+    // 4. Sort (Newest first)
+    history.sort((a, b) => new Date(b.timestamp.replace(' ', 'T') + 'Z').getTime() - new Date(a.timestamp.replace(' ', 'T') + 'Z').getTime());
+    // 5. Save
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(history, null, 2));
+        logQuota(`History Update: Added ${addedCount}, Pruned ${beforePrune - history.length}, Total ${history.length} entries.`);
+    }
+    catch (e) {
+        logQuota(`Failed to save history: ${e}`);
+    }
+    return history;
+}
+// === MAIN QUOTA FUNCTION ===
 export async function getQuotaStatus(forceRefresh = false) {
     const config = loadConfig();
     if (!config.apiKey) {
-        // Pas de clé = Mode manual par défaut, pas de quota
-        return {
-            tierRemaining: 0,
-            tierUsed: 0,
-            tierLimit: 0,
-            walletBalance: 0,
-            nextResetAt: new Date(),
-            timeUntilReset: 0,
-            canUseEnterprise: false,
-            isUsingWallet: false,
-            needsAlert: false,
-            tier: 'none',
-            tierEmoji: '❌'
-        };
+        return createDefaultQuota('none', 0);
     }
     const now = Date.now();
     if (!forceRefresh && cachedQuota && (now - lastQuotaFetch) < CACHE_TTL) {
@@ -44,27 +96,33 @@ export async function getQuotaStatus(forceRefresh = false) {
     }
     try {
         logQuota("Fetching Quota Data...");
+        // 1. Fetch API
         // SEQUENTIAL FETCH (Avoid Rate Limits)
-        // We fetch one by one. If one fails, we catch and return fallback.
         const profileRes = await fetchAPI('/account/profile', config.apiKey);
         const balanceRes = await fetchAPI('/account/balance', config.apiKey);
         const usageRes = await fetchAPI('/account/usage', config.apiKey);
         logQuota(`Fetch Success. Tier: ${profileRes.tier}, Balance: ${balanceRes.balance}`);
         const profile = profileRes;
         const balance = balanceRes.balance;
-        const usage = usageRes.usage || [];
-        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' }; // Default 1 (Spore)
+        // 2. Update Local History (The Source of Truth)
+        const fullHistory = updateLocalHistory(usageRes.usage || []);
+        const tierInfo = TIER_LIMITS[profile.tier] || { pollen: 1, emoji: '❓' };
         const tierLimit = tierInfo.pollen;
-        // Calculer le reset
+        // 3. Calculate Reset & Usage from History
         const resetInfo = calculateResetInfo(profile.nextResetAt);
-        // Calculer l'usage de la période actuelle
-        const { tierUsed } = calculateCurrentPeriodUsage(usage, resetInfo);
+        const { tierUsed } = calculateCurrentPeriodUsage(fullHistory, resetInfo);
+        // 4. Calculate Balances
         const tierRemaining = Math.max(0, tierLimit - tierUsed);
         // Fix rounding errors
         const cleanTierRemaining = Math.max(0, parseFloat(tierRemaining.toFixed(4)));
         // Le wallet c'est le reste (balance totale - ce qu'il reste du tier gratuit non consommé)
+        // Formula: Pollinations Balance = Wallet + TierRemaining.
         const walletBalance = Math.max(0, balance - cleanTierRemaining);
         const cleanWalletBalance = Math.max(0, parseFloat(walletBalance.toFixed(4)));
+        // needsAlert: check BOTH tier threshold AND wallet threshold
+        const tierAlertPercent = tierLimit > 0 ? (cleanTierRemaining / tierLimit * 100) : 0;
+        const tierNeedsAlert = tierLimit > 0 && tierAlertPercent <= config.thresholds.tier;
+        const walletNeedsAlert = cleanWalletBalance > 0 && cleanWalletBalance < (config.thresholds.wallet || 0.5);
         cachedQuota = {
             tierRemaining: cleanTierRemaining,
             tierUsed,
@@ -74,7 +132,7 @@ export async function getQuotaStatus(forceRefresh = false) {
             timeUntilReset: resetInfo.timeUntilReset,
             canUseEnterprise: cleanTierRemaining > 0.05 || cleanWalletBalance > 0.05,
             isUsingWallet: cleanTierRemaining <= 0.05 && cleanWalletBalance > 0.05,
-            needsAlert: tierLimit > 0 ? (cleanTierRemaining / tierLimit * 100) <= config.thresholds.tier : false,
+            needsAlert: tierNeedsAlert || walletNeedsAlert,
             tier: profile.tier,
             tierEmoji: tierInfo.emoji
         };
@@ -84,30 +142,29 @@ export async function getQuotaStatus(forceRefresh = false) {
     catch (e) {
         logQuota(`ERROR fetching quota: ${e.message}`);
         let errorType = 'unknown';
-        if (e.message && e.message.includes('403')) {
+        if (e.message && e.message.includes('403'))
             errorType = 'auth_limited';
-        }
-        else if (e.message && e.message.includes('Network Error')) {
+        else if (e.message && e.message.includes('Network Error'))
             errorType = 'network';
-        }
-        // Retourner le cache ou un état par défaut safe
-        return cachedQuota || {
-            tierRemaining: 0,
-            tierUsed: 0,
-            tierLimit: 1,
-            walletBalance: 0,
-            nextResetAt: new Date(),
-            timeUntilReset: 0,
-            canUseEnterprise: false,
-            isUsingWallet: false,
-            needsAlert: true,
-            tier: 'error',
-            tierEmoji: '⚠️',
-            errorType
-        };
+        return cachedQuota || { ...createDefaultQuota('error', 1), errorType };
     }
 }
-// === HELPERS (Native HTTPS) ===
+function createDefaultQuota(tierName, limit) {
+    return {
+        tierRemaining: 0,
+        tierUsed: 0,
+        tierLimit: limit,
+        walletBalance: 0,
+        nextResetAt: new Date(),
+        timeUntilReset: 0,
+        canUseEnterprise: false,
+        isUsingWallet: false,
+        needsAlert: false,
+        tier: tierName,
+        tierEmoji: TIER_LIMITS[tierName]?.emoji || '❌'
+    };
+}
+// === HELPERS ===
 function fetchAPI(endpoint, apiKey) {
     return new Promise((resolve, reject) => {
         const options = {
@@ -146,28 +203,23 @@ function fetchAPI(endpoint, apiKey) {
 function calculateResetInfo(nextResetAt) {
     const nextResetFromAPI = new Date(nextResetAt);
     const now = new Date();
-    // Extraire l'heure de reset depuis l'API (varie par utilisateur!)
     const resetHour = nextResetFromAPI.getUTCHours();
     const resetMinute = nextResetFromAPI.getUTCMinutes();
     const resetSecond = nextResetFromAPI.getUTCSeconds();
-    // Calculer le reset d'aujourd'hui à cette heure
     const todayResetUTC = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), resetHour, resetMinute, resetSecond));
     let lastReset;
     let nextReset;
     if (now >= todayResetUTC) {
-        // Le reset d'aujourd'hui est passé
         lastReset = todayResetUTC;
-        nextReset = new Date(todayResetUTC.getTime() + 24 * 60 * 60 * 1000);
+        nextReset = new Date(todayResetUTC.getTime() + ONE_DAY_MS);
     }
     else {
-        // Le reset d'aujourd'hui n'est pas encore passé
-        lastReset = new Date(todayResetUTC.getTime() - 24 * 60 * 60 * 1000);
+        lastReset = new Date(todayResetUTC.getTime() - ONE_DAY_MS);
         nextReset = todayResetUTC;
     }
     const timeUntilReset = nextReset.getTime() - now.getTime();
     const timeSinceReset = now.getTime() - lastReset.getTime();
-    const cycleDuration = 24 * 60 * 60 * 1000;
-    const progressPercent = (timeSinceReset / cycleDuration) * 100;
+    const progressPercent = (timeSinceReset / ONE_DAY_MS) * 100;
     return {
         nextReset,
         lastReset,
@@ -182,15 +234,10 @@ function calculateResetInfo(nextResetAt) {
 function calculateCurrentPeriodUsage(usage, resetInfo) {
     let tierUsed = 0;
     let packUsed = 0;
-    // Parser le timestamp de l'API avec Z pour UTC
-    function parseUsageTimestamp(timestamp) {
-        // Format: "2026-01-23 01:11:21"
-        const isoString = timestamp.replace(' ', 'T') + 'Z';
-        return new Date(isoString);
-    }
-    // FILTRER: Ne garder que les entrées APRÈS le dernier reset
     const entriesAfterReset = usage.filter(entry => {
-        const entryTime = parseUsageTimestamp(entry.timestamp);
+        // Safe Parse
+        const timestamp = entry.timestamp.replace(' ', 'T') + 'Z';
+        const entryTime = new Date(timestamp);
         return entryTime >= resetInfo.lastReset;
     });
     for (const entry of entriesAfterReset) {
@@ -203,7 +250,6 @@ function calculateCurrentPeriodUsage(usage, resetInfo) {
     }
     return { tierUsed, packUsed };
 }
-// === EXPORT POUR LES ALERTES ===
 export function formatQuotaForToast(quota) {
     if (quota.errorType === 'auth_limited') {
         return `🔑 CLE LIMITÉE (Génération Seule) | 💎 Wallet: N/A | ⏰ Reset: N/A`;
@@ -211,7 +257,6 @@ export function formatQuotaForToast(quota) {
     const tierPercent = quota.tierLimit > 0
         ? Math.round((quota.tierRemaining / quota.tierLimit) * 100)
         : 0;
-    // Format compact: 1h23m
     const ms = quota.timeUntilReset;
     const hours = Math.floor(ms / (1000 * 60 * 60));
     const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));

package/dist/server/toast.d.ts

@@ -4,3 +4,6 @@ export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'su
 export declare function createToastHooks(client: any): {
     'session.idle': ({ event }: any) => Promise<void>;
 };
+export declare function createToolHooks(client: any): {
+    'tool.execute.after': (input: any, output: any) => Promise<void>;
+};

package/dist/server/toast.js

@@ -76,3 +76,19 @@ export function createToastHooks(client) {
         }
     };
 }
+// 3. CANAL TOOLS (Natif)
+export function createToolHooks(client) {
+    return {
+        'tool.execute.after': async (input, output) => {
+            // Check for metadata in the output
+            if (output.metadata && output.metadata.message) {
+                const meta = output.metadata;
+                const type = meta.type || 'info';
+                // If title is not in metadata, try to use the one from output or default
+                const title = meta.title || output.title || 'Pollinations Tool';
+                // Emit the toast
+                emitStatusToast(type, meta.message, title);
+            }
+        }
+    };
+}

package/dist/tools/design/gen_diagram.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genDiagramTool: ToolDefinition;

package/dist/tools/design/gen_diagram.js

@@ -0,0 +1,94 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+const MERMAID_INK_BASE = 'https://mermaid.ink';
+/**
+ * Encode Mermaid code for mermaid.ink API
+ * Uses base64 encoding of the diagram definition
+ */
+function encodeMermaid(code) {
+    return Buffer.from(code, 'utf-8').toString('base64url');
+}
+/**
+ * Fetch binary content from URL
+ */
+function fetchBinary(url) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'OpenCode-Pollinations-Plugin/6.0' } }, (res) => {
+            // Follow redirects
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetchBinary(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+        req.on('error', reject);
+        req.setTimeout(15000, () => {
+            req.destroy();
+            reject(new Error('Timeout fetching diagram'));
+        });
+    });
+}
+export const genDiagramTool = tool({
+    description: `Render a Mermaid diagram to SVG or PNG image. 
+Uses mermaid.ink (free, no auth required). Supports all Mermaid syntax:
+flowchart, sequenceDiagram, classDiagram, stateDiagram, erDiagram, gantt, pie, mindmap, timeline, etc.
+The diagram code should be valid Mermaid syntax WITHOUT the \`\`\`mermaid fences.`,
+    args: {
+        code: tool.schema.string().describe('Mermaid diagram code (e.g. "graph LR; A-->B; B-->C")'),
+        format: tool.schema.enum(['svg', 'png']).optional().describe('Output format (default: svg)'),
+        theme: tool.schema.enum(['default', 'dark', 'forest', 'neutral']).optional().describe('Diagram theme (default: default)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/diagrams/'),
+    },
+    async execute(args, context) {
+        const format = args.format || 'svg';
+        const theme = args.theme || 'default';
+        const outputDir = resolveOutputDir(TOOL_DIRS.diagrams, args.output_path);
+        // Build mermaid.ink URL
+        // For themed rendering, we wrap with config
+        const themedCode = theme !== 'default'
+            ? `%%{init: {'theme': '${theme}'}}%%\n${args.code}`
+            : args.code;
+        const encoded = encodeMermaid(themedCode);
+        const endpoint = format === 'svg' ? 'svg' : 'img';
+        const url = `${MERMAID_INK_BASE}/${endpoint}/${encoded}`;
+        // Generate filename
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `diagram_${Date.now()}`;
+        const filePath = path.join(outputDir, `${safeName}.${format}`);
+        try {
+            const data = await fetchBinary(url);
+            if (data.length < 50) {
+                return `❌ Diagram Error: mermaid.ink returned empty/invalid response. Check your Mermaid syntax.`;
+            }
+            fs.writeFileSync(filePath, data);
+            const fileSizeKB = (data.length / 1024).toFixed(1);
+            // Extract diagram type from first line
+            const firstLine = args.code.trim().split('\n')[0].trim();
+            const diagramType = firstLine.replace(/[;\s{].*/g, '');
+            context.metadata({ title: `📊 Diagram: ${diagramType}` });
+            return [
+                `📊 Diagram Rendered`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Type: ${diagramType}`,
+                `Theme: ${theme}`,
+                `Format: ${format.toUpperCase()}`,
+                `File: ${filePath}`,
+                `Weight: ${fileSizeKB} KB`,
+                `URL: ${url}`,
+                `Cost: Free (mermaid.ink)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ Diagram Error: ${err.message}\n💡 Verify your Mermaid syntax at https://mermaid.live`;
+        }
+    },
+});

package/dist/tools/design/gen_palette.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genPaletteTool: ToolDefinition;

package/dist/tools/design/gen_palette.js

@@ -0,0 +1,182 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+function hexToHSL(hex) {
+    hex = hex.replace('#', '');
+    if (hex.length === 3)
+        hex = hex.split('').map(c => c + c).join('');
+    const r = parseInt(hex.substring(0, 2), 16) / 255;
+    const g = parseInt(hex.substring(2, 4), 16) / 255;
+    const b = parseInt(hex.substring(4, 6), 16) / 255;
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0;
+    const l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+                break;
+            case g:
+                h = ((b - r) / d + 2) / 6;
+                break;
+            case b:
+                h = ((r - g) / d + 4) / 6;
+                break;
+        }
+    }
+    return { h: Math.round(h * 360), s: Math.round(s * 100), l: Math.round(l * 100) };
+}
+function hslToHex(h, s, l) {
+    s /= 100;
+    l /= 100;
+    const a = s * Math.min(l, 1 - l);
+    const f = (n) => {
+        const k = (n + h / 30) % 12;
+        const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0');
+    };
+    return `#${f(0)}${f(8)}${f(4)}`;
+}
+function generatePalette(baseHex, scheme, count) {
+    const base = hexToHSL(baseHex);
+    const colors = [];
+    switch (scheme) {
+        case 'complementary':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 180) % 360, base.s, base.l), role: 'Complement' });
+            // Fill shades
+            for (let i = 2; i < count; i++) {
+                const lShift = base.l + (i % 2 === 0 ? 15 : -15) * Math.ceil(i / 2);
+                colors.push({ hex: hslToHex(base.h, base.s, Math.max(10, Math.min(90, lShift))), role: `Shade ${i - 1}` });
+            }
+            break;
+        case 'analogous':
+            for (let i = 0; i < count; i++) {
+                const offset = (i - Math.floor(count / 2)) * 30;
+                colors.push({
+                    hex: hslToHex((base.h + offset + 360) % 360, base.s, base.l),
+                    role: offset === 0 ? 'Base' : `${offset > 0 ? '+' : ''}${offset}°`
+                });
+            }
+            break;
+        case 'triadic':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 120) % 360, base.s, base.l), role: 'Triad +120°' });
+            colors.push({ hex: hslToHex((base.h + 240) % 360, base.s, base.l), role: 'Triad +240°' });
+            for (let i = 3; i < count; i++) {
+                const lShift = base.l + (i % 2 === 0 ? 12 : -12) * Math.ceil((i - 2) / 2);
+                colors.push({ hex: hslToHex((base.h + (i * 120)) % 360, base.s, Math.max(10, Math.min(90, lShift))), role: `Accent ${i - 2}` });
+            }
+            break;
+        case 'split-complementary':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 150) % 360, base.s, base.l), role: 'Split +150°' });
+            colors.push({ hex: hslToHex((base.h + 210) % 360, base.s, base.l), role: 'Split +210°' });
+            for (let i = 3; i < count; i++) {
+                colors.push({ hex: hslToHex(base.h, base.s, Math.max(10, Math.min(90, base.l + (i * 10 - 30)))), role: `Tone ${i - 2}` });
+            }
+            break;
+        case 'monochromatic':
+        default:
+            for (let i = 0; i < count; i++) {
+                const l = Math.round(15 + (i / (count - 1)) * 70); // 15% to 85%
+                colors.push({
+                    hex: hslToHex(base.h, base.s, l),
+                    role: l < base.l ? `Dark ${Math.abs(i - Math.floor(count / 2))}` : l === base.l ? 'Base' : `Light ${Math.abs(i - Math.floor(count / 2))}`,
+                });
+            }
+            // Mark closest to base
+            let closestIdx = 0;
+            let closestDiff = Infinity;
+            colors.forEach((c, i) => {
+                const diff = Math.abs(hexToHSL(c.hex).l - base.l);
+                if (diff < closestDiff) {
+                    closestDiff = diff;
+                    closestIdx = i;
+                }
+            });
+            colors[closestIdx].role = 'Base';
+            break;
+    }
+    return colors.slice(0, count);
+}
+function generateSVG(colors) {
+    const swatchW = 120;
+    const swatchH = 80;
+    const gap = 8;
+    const totalW = colors.length * (swatchW + gap) - gap + 40;
+    const totalH = swatchH + 60;
+    const swatches = colors.map((c, i) => {
+        const x = 20 + i * (swatchW + gap);
+        const textColor = hexToHSL(c.hex).l > 50 ? '#1a1a1a' : '#ffffff';
+        return `
+    <rect x="${x}" y="20" width="${swatchW}" height="${swatchH}" rx="8" fill="${c.hex}" stroke="#333" stroke-width="1"/>
+    <text x="${x + swatchW / 2}" y="${swatchH / 2 + 15}" text-anchor="middle" fill="${textColor}" font-family="monospace" font-size="13" font-weight="bold">${c.hex.toUpperCase()}</text>
+    <text x="${x + swatchW / 2}" y="${swatchH + 38}" text-anchor="middle" fill="#666" font-family="sans-serif" font-size="11">${c.role}</text>`;
+    }).join('');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
+  <rect width="100%" height="100%" fill="#0d0d0d" rx="12"/>
+  ${swatches}
+</svg>`;
+}
+export const genPaletteTool = tool({
+    description: `Generate a harmonious color palette from a base hex color.
+Outputs a visual SVG palette + JSON color codes. Works 100% offline.
+Schemes: monochromatic, complementary, analogous, triadic, split-complementary.
+Perfect for frontend design, branding, and UI theming.`,
+    args: {
+        color: tool.schema.string().describe('Base hex color (e.g. "#3B82F6" or "3B82F6")'),
+        scheme: tool.schema.enum(['monochromatic', 'complementary', 'analogous', 'triadic', 'split-complementary']).optional()
+            .describe('Color harmony scheme (default: analogous)'),
+        count: tool.schema.number().min(3).max(8).optional().describe('Number of colors (default: 5, max: 8)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/palettes/'),
+    },
+    async execute(args, context) {
+        const scheme = args.scheme || 'analogous';
+        const count = args.count || 5;
+        // Normalize hex
+        let hex = args.color.trim();
+        if (!hex.startsWith('#'))
+            hex = '#' + hex;
+        if (!/^#[0-9a-fA-F]{3,6}$/.test(hex)) {
+            return `❌ Invalid hex color: "${args.color}". Use format: #3B82F6 or 3B82F6`;
+        }
+        if (hex.length === 4)
+            hex = '#' + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
+        // Generate palette
+        const colors = generatePalette(hex, scheme, count);
+        const outputDir = resolveOutputDir(TOOL_DIRS.palettes, args.output_path);
+        // Save SVG
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `palette_${hex.replace('#', '')}_${scheme}`;
+        const svgPath = path.join(outputDir, `${safeName}.svg`);
+        const svg = generateSVG(colors);
+        fs.writeFileSync(svgPath, svg);
+        // Build CSS custom properties snippet
+        const cssVars = colors.map((c, i) => `  --color-${i + 1}: ${c.hex};`).join('\n');
+        context.metadata({ title: `🎨 Palette: ${scheme} from ${hex}` });
+        const colorTable = colors.map(c => `  ${c.hex.toUpperCase()}  ${c.role}`).join('\n');
+        return [
+            `🎨 Color Palette Generated`,
+            `━━━━━━━━━━━━━━━━━━━━━━━━━`,
+            `Base: ${hex.toUpperCase()}`,
+            `Scheme: ${scheme}`,
+            `Colors (${count}):`,
+            colorTable,
+            ``,
+            `File: ${svgPath}`,
+            ``,
+            `CSS Variables:`,
+            `:root {`,
+            cssVars,
+            `}`,
+            ``,
+            `Cost: Free (local computation)`,
+        ].join('\n');
+    },
+});

package/dist/tools/design/gen_qrcode.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genQrcodeTool: ToolDefinition;

package/dist/tools/design/gen_qrcode.js

@@ -0,0 +1,50 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as QRCode from 'qrcode';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+export const genQrcodeTool = tool({
+    description: `Generate a QR code image from text, URL, or WiFi credentials. 
+Outputs a PNG file saved locally. Works 100% offline, no API key needed.
+Examples: URLs, plain text, WiFi (format: WIFI:T:WPA;S:NetworkName;P:Password;;)`,
+    args: {
+        content: tool.schema.string().describe('The text, URL, or WiFi string to encode into a QR code'),
+        size: tool.schema.number().min(128).max(2048).optional().describe('QR code size in pixels (default: 512)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/qrcodes/'),
+    },
+    async execute(args, context) {
+        const size = args.size || 512;
+        const outputDir = resolveOutputDir(TOOL_DIRS.qrcodes, args.output_path);
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `qr_${Date.now()}`;
+        const filePath = path.join(outputDir, `${safeName}.png`);
+        try {
+            await QRCode.toFile(filePath, args.content, {
+                width: size,
+                margin: 2,
+                color: { dark: '#000000', light: '#ffffff' },
+                errorCorrectionLevel: 'M',
+            });
+            const stats = fs.statSync(filePath);
+            const fileSizeKB = (stats.size / 1024).toFixed(1);
+            const displayContent = args.content.length > 80
+                ? args.content.substring(0, 77) + '...'
+                : args.content;
+            context.metadata({ title: `🔲 QR Code: ${displayContent}` });
+            return [
+                `🔲 QR Code Généré`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Contenu: ${displayContent}`,
+                `Taille: ${size}×${size}px`,
+                `Fichier: ${filePath}`,
+                `Poids: ${fileSizeKB} KB`,
+                `Coût: Gratuit (génération locale)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ Erreur QR Code: ${err.message}`;
+        }
+    },
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 8 tools always available
+ * Enter Universe (with key): +6 Pollinations tools
+ *
+ * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
+ */
+import { genImageTool } from './pollinations/gen_image.js';
+import { genVideoTool } from './pollinations/gen_video.js';
+import { genAudioTool } from './pollinations/gen_audio.js';
+import { transcribeAudioTool } from './pollinations/transcribe_audio.js';
+import { genMusicTool } from './pollinations/gen_music.js';
+import { deepsearchTool } from './pollinations/deepsearch.js';
+import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
+/**
+ * Build the tool registry based on user's access level
+ *
+ * @returns Record<string, Tool> to be spread into the plugin's tool: {} property
+ */
+export declare function createToolRegistry(): Record<string, any>;
+export { genImageTool, genVideoTool, genAudioTool, transcribeAudioTool, genMusicTool, deepsearchTool, searchCrawlScrapeTool, };