@praveencs/agent 0.9.30 → 0.10.0

package/agent-skills/plugins/mongodb/tools/mongodb.js

@@ -0,0 +1,123 @@
+/**
+ * MongoDB automation tool.
+ * Uses the MongoDB Atlas Data API for zero-dependency database operations.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const apiKey = process.env.MONGODB_API_KEY;
+    const appId = process.env.MONGODB_APP_ID;
+    const cluster = args.cluster || process.env.MONGODB_CLUSTER || 'Cluster0';
+    const database = args.database || process.env.MONGODB_DATABASE;
+
+    if (!apiKey || !appId) {
+        throw new Error('MONGODB_API_KEY and MONGODB_APP_ID are required. Enable the Data API at https://cloud.mongodb.com');
+    }
+
+    async function mongoFetch(endpoint, body) {
+        const url = `https://data.mongodb-api.com/app/${appId}/endpoint/data/v1/action/${endpoint}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'api-key': apiKey
+            },
+            body: JSON.stringify({
+                dataSource: cluster,
+                database: database,
+                collection: args.collection,
+                ...body
+            })
+        });
+
+        const data = await res.json();
+        if (!res.ok) throw new Error(`MongoDB API Error: ${JSON.stringify(data)}`);
+        return data;
+    }
+
+    try {
+        switch (action) {
+            case 'find':
+                return await mongoFetch('find', {
+                    filter: args.filter || {},
+                    projection: args.projection,
+                    sort: args.sort,
+                    limit: args.limit || 20
+                });
+
+            case 'find_one':
+                return await mongoFetch('findOne', {
+                    filter: args.filter || {}
+                });
+
+            case 'insert_one':
+                return await mongoFetch('insertOne', {
+                    document: args.document
+                });
+
+            case 'insert_many':
+                return await mongoFetch('insertMany', {
+                    documents: args.documents
+                });
+
+            case 'update_one':
+                return await mongoFetch('updateOne', {
+                    filter: args.filter,
+                    update: args.update,
+                    upsert: args.upsert || false
+                });
+
+            case 'update_many':
+                return await mongoFetch('updateMany', {
+                    filter: args.filter,
+                    update: args.update
+                });
+
+            case 'delete_one':
+                return await mongoFetch('deleteOne', {
+                    filter: args.filter
+                });
+
+            case 'delete_many':
+                return await mongoFetch('deleteMany', {
+                    filter: args.filter
+                });
+
+            case 'aggregate':
+                return await mongoFetch('aggregate', {
+                    pipeline: args.pipeline
+                });
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'mongodb',
+    description: 'Query and manage MongoDB collections via the Atlas Data API. Requires MONGODB_API_KEY and MONGODB_APP_ID.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['find', 'find_one', 'insert_one', 'insert_many', 'update_one', 'update_many', 'delete_one', 'delete_many', 'aggregate']
+            },
+            collection: { type: 'string', description: 'Collection name' },
+            database: { type: 'string', description: 'Database name (override MONGODB_DATABASE)' },
+            cluster: { type: 'string', description: 'Cluster name (default: Cluster0)' },
+            filter: { type: 'object', description: 'MongoDB filter object (e.g., {"status": "active"})' },
+            document: { type: 'object', description: 'Document to insert' },
+            documents: { type: 'array', description: 'Array of documents to insert' },
+            update: { type: 'object', description: 'Update operations (e.g., {"$set": {"name": "new"}})' },
+            projection: { type: 'object', description: 'Fields to include/exclude' },
+            sort: { type: 'object', description: 'Sort order (e.g., {"createdAt": -1})' },
+            pipeline: { type: 'array', description: 'Aggregation pipeline stages' },
+            upsert: { type: 'boolean', description: 'Insert if no match found' },
+            limit: { type: 'number', description: 'Max documents to return' }
+        }
+    }
+};

package/agent-skills/plugins/notion/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "notion",
+    "version": "1.0.0",
+    "description": "Create and manage Notion pages, databases, and blocks for project documentation and knowledge management.",
+    "author": "Praveen",
+    "category": "Productivity",
+    "tags": [
+        "notion",
+        "docs",
+        "wiki",
+        "project-management",
+        "knowledge-base"
+    ],
+    "exports": {
+        "tools": [
+            "tools/notion.js"
+        ],
+        "skills": [
+            "skills/notion-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/notion/skills/notion-manager.md

@@ -0,0 +1,16 @@
+# Notion Manager
+
+## Description
+This skill enables you to create and manage Notion pages, query databases, manage content blocks, and search across a Notion workspace.
+
+## Instructions
+1. When asked to create a Notion page, use the `notion` tool with `action: "create_page"`. Provide either a `database_id` (to add a row to a database) or `parent_page_id` (to create a sub-page).
+2. For simple pages, just provide `title` and `content`. For database entries, construct a `properties` object matching the database schema.
+3. To query a Notion database, use `action: "query_database"` with the `database_id`. Use `filter` for conditions (e.g., `{ "property": "Status", "select": { "equals": "Done" } }`) and `sorts` for ordering.
+4. To add content to an existing page, use `action: "append_blocks"` with the `page_id` and either plain `content` text or structured `children` blocks.
+5. Use `action: "search"` to find pages and databases across the workspace. The query searches titles and content.
+6. Notion IDs are UUIDs (32 hex chars). They appear in page URLs after the workspace name: `notion.so/workspace/Page-Title-<ID>`.
+7. If the tool returns an authentication error, the user needs to export `NOTION_API_KEY`. They must also share target pages/databases with the integration.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/notion/tools/notion.js

@@ -0,0 +1,158 @@
+/**
+ * Notion automation tool.
+ * Provides page/database CRUD via the Notion API (2022-06-28).
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const token = process.env.NOTION_API_KEY;
+
+    if (!token) {
+        throw new Error('NOTION_API_KEY environment variable is not set. Create an integration at https://www.notion.so/my-integrations');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`,
+        'Notion-Version': '2022-06-28'
+    };
+
+    async function notionFetch(method, endpoint, body = null) {
+        const url = `https://api.notion.com/v1${endpoint}`;
+        const options = { method, headers };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(url, options);
+        const data = await res.json();
+
+        if (!res.ok) {
+            throw new Error(`Notion API Error (${res.status}): ${data.message || JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    /** Helper to build rich text array from plain string */
+    function richText(text) {
+        return [{ type: 'text', text: { content: text } }];
+    }
+
+    try {
+        switch (action) {
+            // --- PAGES ---
+            case 'create_page':
+                return await notionFetch('POST', '/pages', {
+                    parent: args.database_id
+                        ? { database_id: args.database_id }
+                        : { page_id: args.parent_page_id },
+                    properties: args.properties || {
+                        title: { title: richText(args.title || 'Untitled') }
+                    },
+                    children: args.children || (args.content ? [
+                        {
+                            object: 'block',
+                            type: 'paragraph',
+                            paragraph: { rich_text: richText(args.content) }
+                        }
+                    ] : [])
+                });
+
+            case 'update_page':
+                return await notionFetch('PATCH', `/pages/${args.page_id}`, {
+                    properties: args.properties || {}
+                });
+
+            case 'get_page':
+                return await notionFetch('GET', `/pages/${args.page_id}`);
+
+            case 'archive_page':
+                return await notionFetch('PATCH', `/pages/${args.page_id}`, {
+                    archived: true
+                });
+
+            // --- BLOCKS (Page Content) ---
+            case 'get_blocks':
+                return await notionFetch('GET', `/blocks/${args.block_id || args.page_id}/children?page_size=${args.page_size || 100}`);
+
+            case 'append_blocks':
+                return await notionFetch('PATCH', `/blocks/${args.page_id}/children`, {
+                    children: args.children || [
+                        {
+                            object: 'block',
+                            type: 'paragraph',
+                            paragraph: { rich_text: richText(args.content || '') }
+                        }
+                    ]
+                });
+
+            case 'delete_block':
+                return await notionFetch('DELETE', `/blocks/${args.block_id}`);
+
+            // --- DATABASES ---
+            case 'query_database':
+                return await notionFetch('POST', `/databases/${args.database_id}/query`, {
+                    filter: args.filter || undefined,
+                    sorts: args.sorts || undefined,
+                    page_size: args.page_size || 100
+                });
+
+            case 'create_database':
+                return await notionFetch('POST', '/databases', {
+                    parent: { page_id: args.parent_page_id },
+                    title: richText(args.title || 'New Database'),
+                    properties: args.properties || {
+                        Name: { title: {} }
+                    }
+                });
+
+            // --- SEARCH ---
+            case 'search':
+                return await notionFetch('POST', '/search', {
+                    query: args.query || '',
+                    filter: args.filter || undefined,
+                    sort: args.sort || { direction: 'descending', timestamp: 'last_edited_time' },
+                    page_size: args.page_size || 20
+                });
+
+            // --- USERS ---
+            case 'list_users':
+                return await notionFetch('GET', '/users');
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'notion',
+    description: 'Interact with Notion to create/update pages, query databases, manage blocks, and search workspace content. Requires NOTION_API_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Notion operation to perform',
+                enum: [
+                    'create_page', 'update_page', 'get_page', 'archive_page',
+                    'get_blocks', 'append_blocks', 'delete_block',
+                    'query_database', 'create_database',
+                    'search', 'list_users'
+                ]
+            },
+            page_id: { type: 'string', description: 'Notion page ID' },
+            parent_page_id: { type: 'string', description: 'Parent page ID (for creating sub-pages or databases)' },
+            database_id: { type: 'string', description: 'Notion database ID' },
+            block_id: { type: 'string', description: 'Notion block ID' },
+            title: { type: 'string', description: 'Title for pages or databases' },
+            content: { type: 'string', description: 'Text content to add as a paragraph block' },
+            properties: { type: 'object', description: 'Notion properties object (for pages or databases)' },
+            children: { type: 'array', description: 'Array of Notion block objects to add' },
+            filter: { type: 'object', description: 'Notion filter object (for database queries or search)' },
+            sorts: { type: 'array', description: 'Notion sorts array (for database queries)' },
+            query: { type: 'string', description: 'Search query text' },
+            page_size: { type: 'number', description: 'Max results per page (default: 100)' }
+        }
+    }
+};

package/agent-skills/plugins/openai/plugin.json

@@ -0,0 +1,23 @@
+{
+    "name": "openai",
+    "version": "1.0.0",
+    "description": "Direct access to OpenAI APIs: GPT chat, DALL-E image generation, Whisper transcription, and TTS.",
+    "author": "Praveen",
+    "category": "AI & Specialized",
+    "tags": [
+        "openai",
+        "gpt",
+        "dalle",
+        "whisper",
+        "tts",
+        "ai"
+    ],
+    "exports": {
+        "tools": [
+            "tools/openai.js"
+        ],
+        "skills": [
+            "skills/openai-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/openai/skills/openai-manager.md

@@ -0,0 +1,15 @@
+# OpenAI Manager
+
+## Description
+This skill gives you direct access to OpenAI's APIs for chat completions, image generation, speech transcription, text-to-speech, and embeddings.
+
+## Instructions
+1. For chat completions, use `action: "chat"` with either a simple `prompt` string or a full `messages` array for multi-turn conversations.
+2. For image generation, use `action: "generate_image"` with a descriptive `prompt`. DALL-E 3 supports sizes: `1024x1024`, `1792x1024` (landscape), `1024x1792` (portrait).
+3. For text-to-speech, use `action: "text_to_speech"` with `input` text and a `voice` (alloy, echo, fable, onyx, nova, shimmer).
+4. Use `json_mode: true` in chat to force the model to return valid JSON. Useful for structured data extraction.
+5. For embeddings, use `action: "embed"` with `input` text. Returns a vector for semantic search.
+6. If the tool returns an auth error, the user needs to export `OPENAI_API_KEY` from https://platform.openai.com/api-keys.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/openai/tools/openai.js

@@ -0,0 +1,137 @@
+/**
+ * OpenAI automation tool.
+ * Provides direct access to GPT chat completions, DALL-E, Whisper, and TTS via the OpenAI REST API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const apiKey = process.env.OPENAI_API_KEY;
+
+    if (!apiKey) {
+        throw new Error('OPENAI_API_KEY environment variable is not set. Get one at https://platform.openai.com/api-keys');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+    };
+
+    async function oaiFetch(method, endpoint, body = null, isFormData = false) {
+        const url = `https://api.openai.com/v1${endpoint}`;
+        const options = { method };
+        if (isFormData) {
+            options.headers = { 'Authorization': `Bearer ${apiKey}` };
+            options.body = body; // FormData
+        } else {
+            options.headers = headers;
+            if (body) options.body = JSON.stringify(body);
+        }
+
+        const res = await fetch(url, options);
+        const contentType = res.headers.get('content-type') || '';
+
+        if (contentType.includes('audio')) {
+            // TTS returns audio bytes
+            const buffer = await res.arrayBuffer();
+            return { success: true, audioBytes: buffer.byteLength, note: 'Audio data returned (write to file to play)' };
+        }
+
+        const data = await res.json();
+        if (!res.ok) {
+            throw new Error(`OpenAI API Error: ${data.error?.message || JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- CHAT COMPLETIONS ---
+            case 'chat':
+                return await oaiFetch('POST', '/chat/completions', {
+                    model: args.model || 'gpt-4o-mini',
+                    messages: args.messages || [{ role: 'user', content: args.prompt }],
+                    temperature: args.temperature ?? 0.7,
+                    max_tokens: args.max_tokens || 1024,
+                    response_format: args.json_mode ? { type: 'json_object' } : undefined
+                });
+
+            // --- IMAGE GENERATION (DALL-E) ---
+            case 'generate_image':
+                return await oaiFetch('POST', '/images/generations', {
+                    model: args.model || 'dall-e-3',
+                    prompt: args.prompt,
+                    n: args.n || 1,
+                    size: args.size || '1024x1024',
+                    quality: args.quality || 'standard',
+                    style: args.style || 'vivid'
+                });
+
+            // --- SPEECH TO TEXT (WHISPER) ---
+            case 'transcribe': {
+                // Note: requires audio file content — in practice the agent would
+                // read a file and pass its path for the host to handle
+                return await oaiFetch('POST', '/audio/transcriptions', {
+                    model: 'whisper-1',
+                    file: args.file,
+                    language: args.language
+                });
+            }
+
+            // --- TEXT TO SPEECH ---
+            case 'text_to_speech':
+                return await oaiFetch('POST', '/audio/speech', {
+                    model: args.model || 'tts-1',
+                    input: args.input || args.text,
+                    voice: args.voice || 'alloy',
+                    response_format: args.format || 'mp3'
+                });
+
+            // --- EMBEDDINGS ---
+            case 'embed':
+                return await oaiFetch('POST', '/embeddings', {
+                    model: args.model || 'text-embedding-3-small',
+                    input: args.input || args.text
+                });
+
+            // --- MODELS ---
+            case 'list_models':
+                return await oaiFetch('GET', '/models');
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'openai',
+    description: 'Direct access to OpenAI APIs: GPT chat, DALL-E image generation, Whisper transcription, TTS, and embeddings. Requires OPENAI_API_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The OpenAI operation to perform',
+                enum: ['chat', 'generate_image', 'transcribe', 'text_to_speech', 'embed', 'list_models']
+            },
+            prompt: { type: 'string', description: 'Text prompt for chat or image generation' },
+            messages: { type: 'array', description: 'Array of chat messages [{role, content}]' },
+            model: { type: 'string', description: 'Model to use (gpt-4o, gpt-4o-mini, dall-e-3, tts-1, whisper-1)' },
+            temperature: { type: 'number', description: 'Creativity (0-2, default 0.7)' },
+            max_tokens: { type: 'number', description: 'Max output tokens (default 1024)' },
+            json_mode: { type: 'boolean', description: 'Enable JSON response format for chat' },
+            n: { type: 'number', description: 'Number of images to generate (DALL-E)' },
+            size: { type: 'string', description: 'Image size: 1024x1024, 1792x1024, 1024x1792' },
+            quality: { type: 'string', description: 'Image quality: standard or hd' },
+            style: { type: 'string', description: 'Image style: vivid or natural' },
+            input: { type: 'string', description: 'Text input for TTS or embeddings' },
+            text: { type: 'string', description: 'Alias for input/prompt' },
+            voice: { type: 'string', description: 'TTS voice: alloy, echo, fable, onyx, nova, shimmer' },
+            format: { type: 'string', description: 'Audio format: mp3, opus, aac, flac' },
+            file: { type: 'string', description: 'Audio file path for transcription' },
+            language: { type: 'string', description: 'Language code for transcription (e.g., en, es)' }
+        }
+    }
+};

package/agent-skills/plugins/resend/plugin.json

@@ -0,0 +1,21 @@
+{
+    "name": "resend",
+    "version": "1.0.0",
+    "description": "Send transactional and marketing emails via the Resend API.",
+    "author": "Praveen",
+    "category": "Communication",
+    "tags": [
+        "resend",
+        "email",
+        "smtp",
+        "transactional"
+    ],
+    "exports": {
+        "tools": [
+            "tools/resend.js"
+        ],
+        "skills": [
+            "skills/resend-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/resend/skills/resend-manager.md

@@ -0,0 +1,15 @@
+# Resend Manager
+
+## Description
+This skill enables you to send transactional and marketing emails, manage domains, and track delivery via Resend.
+
+## Instructions
+1. To send an email, use `action: "send_email"` with `from`, `to`, `subject`, and either `html` or `text`.
+2. The `from` field must use a verified domain (e.g., `"Agent <noreply@yourdomain.com>"`). For testing, use `onboarding@resend.dev`.
+3. For batch sending, use `action: "send_batch"` with `emails` as an array of email objects.
+4. Use `action: "get_email"` with `email_id` to check delivery status of a sent email.
+5. Before using a custom domain, add it with `add_domain` then verify with `verify_domain`.
+6. Requires `RESEND_API_KEY` from https://resend.com/api-keys.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/resend/tools/resend.js

@@ -0,0 +1,102 @@
+/**
+ * Resend email automation tool.
+ * Modern email API for transactional and marketing emails.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const apiKey = process.env.RESEND_API_KEY;
+
+    if (!apiKey) {
+        throw new Error('RESEND_API_KEY environment variable is not set. Get one at https://resend.com/api-keys');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+    };
+
+    async function resendFetch(method, endpoint, body = null) {
+        const url = `https://api.resend.com${endpoint}`;
+        const options = { method, headers };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(url, options);
+        if (res.status === 204) return { success: true };
+        const data = await res.json();
+        if (!res.ok) throw new Error(`Resend API Error: ${JSON.stringify(data)}`);
+        return data;
+    }
+
+    try {
+        switch (action) {
+            case 'send_email':
+                return await resendFetch('POST', '/emails', {
+                    from: args.from,
+                    to: Array.isArray(args.to) ? args.to : [args.to],
+                    subject: args.subject,
+                    html: args.html,
+                    text: args.text,
+                    cc: args.cc,
+                    bcc: args.bcc,
+                    reply_to: args.reply_to,
+                    tags: args.tags
+                });
+
+            case 'send_batch':
+                return await resendFetch('POST', '/emails/batch', args.emails);
+
+            case 'get_email':
+                return await resendFetch('GET', `/emails/${args.email_id}`);
+
+            case 'list_domains':
+                return await resendFetch('GET', '/domains');
+
+            case 'add_domain':
+                return await resendFetch('POST', '/domains', {
+                    name: args.domain
+                });
+
+            case 'verify_domain':
+                return await resendFetch('POST', `/domains/${args.domain_id}/verify`);
+
+            case 'delete_domain':
+                return await resendFetch('DELETE', `/domains/${args.domain_id}`);
+
+            case 'list_api_keys':
+                return await resendFetch('GET', '/api-keys');
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'resend',
+    description: 'Send emails, manage domains, and track delivery via the Resend API. Requires RESEND_API_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['send_email', 'send_batch', 'get_email', 'list_domains', 'add_domain', 'verify_domain', 'delete_domain', 'list_api_keys']
+            },
+            from: { type: 'string', description: 'Sender email (e.g., "Acme <noreply@acme.com>")' },
+            to: { type: 'string', description: 'Recipient email(s) — string or array' },
+            subject: { type: 'string', description: 'Email subject line' },
+            html: { type: 'string', description: 'HTML email body' },
+            text: { type: 'string', description: 'Plain text email body' },
+            cc: { type: 'array', items: { type: 'string' }, description: 'CC recipients' },
+            bcc: { type: 'array', items: { type: 'string' }, description: 'BCC recipients' },
+            reply_to: { type: 'string', description: 'Reply-to address' },
+            tags: { type: 'array', description: 'Email tags for tracking [{name, value}]' },
+            emails: { type: 'array', description: 'Array of email objects for batch send' },
+            email_id: { type: 'string', description: 'Email ID for status lookup' },
+            domain: { type: 'string', description: 'Domain name to add' },
+            domain_id: { type: 'string', description: 'Domain ID for verification/deletion' }
+        }
+    }
+};

package/agent-skills/plugins/slack/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "slack",
+    "version": "1.0.0",
+    "description": "Send messages, manage channels, search history, and upload files to Slack workspaces.",
+    "author": "Praveen",
+    "category": "Communication",
+    "tags": [
+        "slack",
+        "messaging",
+        "chat",
+        "notifications",
+        "team"
+    ],
+    "exports": {
+        "tools": [
+            "tools/slack.js"
+        ],
+        "skills": [
+            "skills/slack-manager.md"
+        ]
+    }
+}