opc-agent 2.1.0 → 3.0.1

package/dist/tools/integrations/index.d.ts

@@ -0,0 +1,30 @@
+import type { MCPTool } from '../mcp';
+export { SlackTool } from './slack';
+export { EmailSendTool } from './email-send';
+export { WebhookTool } from './webhook';
+export { NotionTool } from './notion';
+export { GitHubTool } from './github-tool';
+export { JiraTool } from './jira';
+export { CalendarTool } from './calendar';
+export { TrelloTool } from './trello';
+export { WebSearchTool } from './web-search';
+export { WebScraperTool } from './web-scraper';
+export { DatabaseTool } from './database';
+export { VectorSearchTool } from './vector-search';
+export { CodeExecutionTool } from './code-exec';
+export { GitTool } from './git-tool';
+export { NpmTool } from './npm-tool';
+export { ImageGenerationTool } from './image-gen';
+export { PDFReaderTool } from './pdf-reader';
+export { CSVAnalyzerTool } from './csv-analyzer';
+export { SummarizerTool } from './summarizer';
+export { TranslatorTool } from './translator';
+/**
+ * Get all 20 pre-built integration tools.
+ */
+export declare function getAllIntegrationTools(): MCPTool[];
+/**
+ * Get a specific integration tool by name.
+ */
+export declare function getIntegrationTool(name: string): MCPTool | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/integrations/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslatorTool = exports.SummarizerTool = exports.CSVAnalyzerTool = exports.PDFReaderTool = exports.ImageGenerationTool = exports.NpmTool = exports.GitTool = exports.CodeExecutionTool = exports.VectorSearchTool = exports.DatabaseTool = exports.WebScraperTool = exports.WebSearchTool = exports.TrelloTool = exports.CalendarTool = exports.JiraTool = exports.GitHubTool = exports.NotionTool = exports.WebhookTool = exports.EmailSendTool = exports.SlackTool = void 0;
+exports.getAllIntegrationTools = getAllIntegrationTools;
+exports.getIntegrationTool = getIntegrationTool;
+// Communication
+var slack_1 = require("./slack");
+Object.defineProperty(exports, "SlackTool", { enumerable: true, get: function () { return slack_1.SlackTool; } });
+var email_send_1 = require("./email-send");
+Object.defineProperty(exports, "EmailSendTool", { enumerable: true, get: function () { return email_send_1.EmailSendTool; } });
+var webhook_1 = require("./webhook");
+Object.defineProperty(exports, "WebhookTool", { enumerable: true, get: function () { return webhook_1.WebhookTool; } });
+// Productivity
+var notion_1 = require("./notion");
+Object.defineProperty(exports, "NotionTool", { enumerable: true, get: function () { return notion_1.NotionTool; } });
+var github_tool_1 = require("./github-tool");
+Object.defineProperty(exports, "GitHubTool", { enumerable: true, get: function () { return github_tool_1.GitHubTool; } });
+var jira_1 = require("./jira");
+Object.defineProperty(exports, "JiraTool", { enumerable: true, get: function () { return jira_1.JiraTool; } });
+var calendar_1 = require("./calendar");
+Object.defineProperty(exports, "CalendarTool", { enumerable: true, get: function () { return calendar_1.CalendarTool; } });
+var trello_1 = require("./trello");
+Object.defineProperty(exports, "TrelloTool", { enumerable: true, get: function () { return trello_1.TrelloTool; } });
+// Data & Search
+var web_search_1 = require("./web-search");
+Object.defineProperty(exports, "WebSearchTool", { enumerable: true, get: function () { return web_search_1.WebSearchTool; } });
+var web_scraper_1 = require("./web-scraper");
+Object.defineProperty(exports, "WebScraperTool", { enumerable: true, get: function () { return web_scraper_1.WebScraperTool; } });
+var database_1 = require("./database");
+Object.defineProperty(exports, "DatabaseTool", { enumerable: true, get: function () { return database_1.DatabaseTool; } });
+var vector_search_1 = require("./vector-search");
+Object.defineProperty(exports, "VectorSearchTool", { enumerable: true, get: function () { return vector_search_1.VectorSearchTool; } });
+// Code & Dev
+var code_exec_1 = require("./code-exec");
+Object.defineProperty(exports, "CodeExecutionTool", { enumerable: true, get: function () { return code_exec_1.CodeExecutionTool; } });
+var git_tool_1 = require("./git-tool");
+Object.defineProperty(exports, "GitTool", { enumerable: true, get: function () { return git_tool_1.GitTool; } });
+var npm_tool_1 = require("./npm-tool");
+Object.defineProperty(exports, "NpmTool", { enumerable: true, get: function () { return npm_tool_1.NpmTool; } });
+// Media & Files
+var image_gen_1 = require("./image-gen");
+Object.defineProperty(exports, "ImageGenerationTool", { enumerable: true, get: function () { return image_gen_1.ImageGenerationTool; } });
+var pdf_reader_1 = require("./pdf-reader");
+Object.defineProperty(exports, "PDFReaderTool", { enumerable: true, get: function () { return pdf_reader_1.PDFReaderTool; } });
+var csv_analyzer_1 = require("./csv-analyzer");
+Object.defineProperty(exports, "CSVAnalyzerTool", { enumerable: true, get: function () { return csv_analyzer_1.CSVAnalyzerTool; } });
+// AI & Analysis
+var summarizer_1 = require("./summarizer");
+Object.defineProperty(exports, "SummarizerTool", { enumerable: true, get: function () { return summarizer_1.SummarizerTool; } });
+var translator_1 = require("./translator");
+Object.defineProperty(exports, "TranslatorTool", { enumerable: true, get: function () { return translator_1.TranslatorTool; } });
+// Import all tools for registry
+const slack_2 = require("./slack");
+const email_send_2 = require("./email-send");
+const webhook_2 = require("./webhook");
+const notion_2 = require("./notion");
+const github_tool_2 = require("./github-tool");
+const jira_2 = require("./jira");
+const calendar_2 = require("./calendar");
+const trello_2 = require("./trello");
+const web_search_2 = require("./web-search");
+const web_scraper_2 = require("./web-scraper");
+const database_2 = require("./database");
+const vector_search_2 = require("./vector-search");
+const code_exec_2 = require("./code-exec");
+const git_tool_2 = require("./git-tool");
+const npm_tool_2 = require("./npm-tool");
+const image_gen_2 = require("./image-gen");
+const pdf_reader_2 = require("./pdf-reader");
+const csv_analyzer_2 = require("./csv-analyzer");
+const summarizer_2 = require("./summarizer");
+const translator_2 = require("./translator");
+const ALL_INTEGRATION_TOOLS = [
+    slack_2.SlackTool,
+    email_send_2.EmailSendTool,
+    webhook_2.WebhookTool,
+    notion_2.NotionTool,
+    github_tool_2.GitHubTool,
+    jira_2.JiraTool,
+    calendar_2.CalendarTool,
+    trello_2.TrelloTool,
+    web_search_2.WebSearchTool,
+    web_scraper_2.WebScraperTool,
+    database_2.DatabaseTool,
+    vector_search_2.VectorSearchTool,
+    code_exec_2.CodeExecutionTool,
+    git_tool_2.GitTool,
+    npm_tool_2.NpmTool,
+    image_gen_2.ImageGenerationTool,
+    pdf_reader_2.PDFReaderTool,
+    csv_analyzer_2.CSVAnalyzerTool,
+    summarizer_2.SummarizerTool,
+    translator_2.TranslatorTool,
+];
+/**
+ * Get all 20 pre-built integration tools.
+ */
+function getAllIntegrationTools() {
+    return [...ALL_INTEGRATION_TOOLS];
+}
+/**
+ * Get a specific integration tool by name.
+ */
+function getIntegrationTool(name) {
+    return ALL_INTEGRATION_TOOLS.find((t) => t.name === name);
+}
+//# sourceMappingURL=index.js.map

package/dist/tools/integrations/jira.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const JiraTool: MCPTool;
+//# sourceMappingURL=jira.d.ts.map

package/dist/tools/integrations/jira.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JiraTool = void 0;
+exports.JiraTool = {
+    name: 'jira',
+    description: 'Interact with Jira: create issues, update status, search, add comments. Requires JIRA_URL, JIRA_EMAIL, JIRA_API_TOKEN env vars.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['create_issue', 'update_status', 'search', 'add_comment'], description: 'Action to perform' },
+            project: { type: 'string', description: 'Project key (for create_issue)' },
+            summary: { type: 'string', description: 'Issue summary' },
+            description: { type: 'string', description: 'Issue description' },
+            issue_type: { type: 'string', description: 'Issue type (default: Task)' },
+            issue_key: { type: 'string', description: 'Issue key (e.g., PROJ-123)' },
+            status: { type: 'string', description: 'Target status (for update_status)' },
+            comment: { type: 'string', description: 'Comment text' },
+            jql: { type: 'string', description: 'JQL query (for search)' },
+        },
+        required: ['action'],
+    },
+    async execute(input) {
+        const baseUrl = process.env.JIRA_URL;
+        const email = process.env.JIRA_EMAIL;
+        const apiToken = process.env.JIRA_API_TOKEN;
+        if (!baseUrl || !email || !apiToken)
+            return { content: 'Error: JIRA_URL, JIRA_EMAIL, JIRA_API_TOKEN required', isError: true };
+        const auth = Buffer.from(`${email}:${apiToken}`).toString('base64');
+        const headers = { 'Authorization': `Basic ${auth}`, 'Content-Type': 'application/json', 'Accept': 'application/json' };
+        const action = String(input.action ?? '');
+        try {
+            if (action === 'create_issue') {
+                if (!input.project || !input.summary)
+                    return { content: 'Error: project, summary required', isError: true };
+                const res = await fetch(`${baseUrl}/rest/api/3/issue`, {
+                    method: 'POST', headers,
+                    body: JSON.stringify({
+                        fields: {
+                            project: { key: input.project },
+                            summary: input.summary,
+                            description: input.description ? { type: 'doc', version: 1, content: [{ type: 'paragraph', content: [{ type: 'text', text: String(input.description) }] }] } : undefined,
+                            issuetype: { name: String(input.issue_type ?? 'Task') },
+                        },
+                    }),
+                });
+                const data = await res.json();
+                return { content: `Issue created: ${data.key}` };
+            }
+            if (action === 'update_status') {
+                if (!input.issue_key || !input.status)
+                    return { content: 'Error: issue_key, status required', isError: true };
+                const trRes = await fetch(`${baseUrl}/rest/api/3/issue/${input.issue_key}/transitions`, { headers });
+                const trData = await trRes.json();
+                const transition = trData.transitions?.find((t) => t.name.toLowerCase() === String(input.status).toLowerCase());
+                if (!transition)
+                    return { content: `No transition found for status: ${input.status}`, isError: true };
+                await fetch(`${baseUrl}/rest/api/3/issue/${input.issue_key}/transitions`, {
+                    method: 'POST', headers, body: JSON.stringify({ transition: { id: transition.id } }),
+                });
+                return { content: `${input.issue_key} moved to ${input.status}` };
+            }
+            if (action === 'search') {
+                if (!input.jql)
+                    return { content: 'Error: jql required', isError: true };
+                const res = await fetch(`${baseUrl}/rest/api/3/search?jql=${encodeURIComponent(String(input.jql))}&maxResults=20`, { headers });
+                const data = await res.json();
+                return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
+            }
+            if (action === 'add_comment') {
+                if (!input.issue_key || !input.comment)
+                    return { content: 'Error: issue_key, comment required', isError: true };
+                await fetch(`${baseUrl}/rest/api/3/issue/${input.issue_key}/comment`, {
+                    method: 'POST', headers,
+                    body: JSON.stringify({ body: { type: 'doc', version: 1, content: [{ type: 'paragraph', content: [{ type: 'text', text: String(input.comment) }] }] } }),
+                });
+                return { content: `Comment added to ${input.issue_key}` };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `Jira error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=jira.js.map

package/dist/tools/integrations/notion.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const NotionTool: MCPTool;
+//# sourceMappingURL=notion.d.ts.map

package/dist/tools/integrations/notion.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotionTool = void 0;
+exports.NotionTool = {
+    name: 'notion',
+    description: 'Interact with Notion API: create pages, search, append blocks. Requires NOTION_API_KEY env var.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['create_page', 'search', 'append_block'], description: 'Action to perform' },
+            parent_id: { type: 'string', description: 'Parent page/database ID' },
+            title: { type: 'string', description: 'Page title (for create_page)' },
+            content: { type: 'string', description: 'Content text (for create_page or append_block)' },
+            query: { type: 'string', description: 'Search query (for search)' },
+            block_id: { type: 'string', description: 'Block ID (for append_block)' },
+        },
+        required: ['action'],
+    },
+    async execute(input) {
+        const apiKey = process.env.NOTION_API_KEY;
+        if (!apiKey)
+            return { content: 'Error: NOTION_API_KEY required', isError: true };
+        const action = String(input.action ?? '');
+        const headers = {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'Notion-Version': '2022-06-28',
+        };
+        try {
+            if (action === 'create_page') {
+                if (!input.parent_id)
+                    return { content: 'Error: parent_id required', isError: true };
+                const res = await fetch('https://api.notion.com/v1/pages', {
+                    method: 'POST', headers,
+                    body: JSON.stringify({
+                        parent: { page_id: input.parent_id },
+                        properties: { title: { title: [{ text: { content: String(input.title ?? 'Untitled') } }] } },
+                        children: input.content ? [{ object: 'block', type: 'paragraph', paragraph: { rich_text: [{ text: { content: String(input.content) } }] } }] : [],
+                    }),
+                });
+                const data = await res.json();
+                return { content: `Page created: ${data.id ?? 'unknown'}` };
+            }
+            if (action === 'search') {
+                const res = await fetch('https://api.notion.com/v1/search', {
+                    method: 'POST', headers,
+                    body: JSON.stringify({ query: String(input.query ?? '') }),
+                });
+                const data = await res.json();
+                return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
+            }
+            if (action === 'append_block') {
+                if (!input.block_id)
+                    return { content: 'Error: block_id required', isError: true };
+                const res = await fetch(`https://api.notion.com/v1/blocks/${input.block_id}/children`, {
+                    method: 'PATCH', headers,
+                    body: JSON.stringify({
+                        children: [{ object: 'block', type: 'paragraph', paragraph: { rich_text: [{ text: { content: String(input.content ?? '') } }] } }],
+                    }),
+                });
+                const data = await res.json();
+                return { content: `Block appended: ${JSON.stringify(data).slice(0, 500)}` };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `Notion error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=notion.js.map

package/dist/tools/integrations/npm-tool.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const NpmTool: MCPTool;
+//# sourceMappingURL=npm-tool.d.ts.map

package/dist/tools/integrations/npm-tool.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmTool = void 0;
+exports.NpmTool = {
+    name: 'npm',
+    description: 'Search npm registry, get package info, or list installed packages.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['search', 'info', 'install'], description: 'Action' },
+            package: { type: 'string', description: 'Package name' },
+            query: { type: 'string', description: 'Search query (for search)' },
+        },
+        required: ['action'],
+    },
+    async execute(input) {
+        const action = String(input.action ?? '');
+        try {
+            if (action === 'search') {
+                const q = String(input.query ?? input.package ?? '');
+                if (!q)
+                    return { content: 'Error: query required', isError: true };
+                const res = await fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(q)}&size=10`);
+                const data = await res.json();
+                const results = (data.objects ?? []).map((o) => `${o.package.name}@${o.package.version} — ${o.package.description}`).join('\n');
+                return { content: results || 'No results' };
+            }
+            if (action === 'info') {
+                const pkg = String(input.package ?? '');
+                if (!pkg)
+                    return { content: 'Error: package required', isError: true };
+                const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(pkg)}`);
+                if (!res.ok)
+                    return { content: `Package not found: ${pkg}`, isError: true };
+                const data = await res.json();
+                const latest = data['dist-tags']?.latest;
+                return { content: `${data.name}@${latest}\n${data.description}\nLicense: ${data.license}\nHomepage: ${data.homepage}` };
+            }
+            if (action === 'install') {
+                return { content: 'Error: npm install is not supported via this tool for security. Use shell access instead.', isError: true };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `NPM error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=npm-tool.js.map

package/dist/tools/integrations/pdf-reader.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const PDFReaderTool: MCPTool;
+//# sourceMappingURL=pdf-reader.d.ts.map

package/dist/tools/integrations/pdf-reader.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFReaderTool = void 0;
+const fs = __importStar(require("fs"));
+exports.PDFReaderTool = {
+    name: 'pdf-reader',
+    description: 'Extract text content from a PDF file. Uses basic binary parsing (no external deps).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Path to PDF file' },
+            url: { type: 'string', description: 'URL of PDF file (alternative to file_path)' },
+            max_length: { type: 'number', description: 'Max characters to return (default: 5000)' },
+        },
+        required: [],
+    },
+    async execute(input) {
+        const maxLen = Number(input.max_length ?? 5000);
+        try {
+            let buffer;
+            if (input.url) {
+                const res = await fetch(String(input.url));
+                if (!res.ok)
+                    return { content: `HTTP ${res.status}`, isError: true };
+                buffer = Buffer.from(await res.arrayBuffer());
+            }
+            else if (input.file_path) {
+                buffer = fs.readFileSync(String(input.file_path));
+            }
+            else {
+                return { content: 'Error: file_path or url required', isError: true };
+            }
+            // Basic PDF text extraction — find text between BT/ET markers and decode
+            const content = buffer.toString('latin1');
+            const textParts = [];
+            // Extract text from stream objects
+            const streamRegex = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+            let match;
+            while ((match = streamRegex.exec(content)) !== null) {
+                const stream = match[1];
+                // Extract text shown with Tj or TJ operators
+                const tjRegex = /\(([^)]*)\)\s*Tj/g;
+                let tjMatch;
+                while ((tjMatch = tjRegex.exec(stream)) !== null) {
+                    textParts.push(tjMatch[1]);
+                }
+            }
+            const text = textParts.join(' ').replace(/\\n/g, '\n').replace(/\\\(/g, '(').replace(/\\\)/g, ')');
+            if (!text.trim())
+                return { content: '(No extractable text found — PDF may use compressed streams. Consider using a dedicated PDF library.)' };
+            return { content: text.slice(0, maxLen), metadata: { pages_approx: (content.match(/\/Type\s*\/Page[^s]/g) || []).length } };
+        }
+        catch (err) {
+            return { content: `PDF error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=pdf-reader.js.map

package/dist/tools/integrations/slack.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const SlackTool: MCPTool;
+//# sourceMappingURL=slack.d.ts.map

package/dist/tools/integrations/slack.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackTool = void 0;
+exports.SlackTool = {
+    name: 'slack',
+    description: 'Send messages to Slack channels, list channels, or search messages. Requires SLACK_WEBHOOK_URL or SLACK_BOT_TOKEN env var.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['send_message', 'list_channels', 'search'], description: 'Action to perform' },
+            channel: { type: 'string', description: 'Channel name or ID (for send_message)' },
+            text: { type: 'string', description: 'Message text (for send_message) or search query (for search)' },
+        },
+        required: ['action'],
+    },
+    async execute(input) {
+        const action = String(input.action ?? '');
+        const token = process.env.SLACK_BOT_TOKEN;
+        const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+        try {
+            if (action === 'send_message') {
+                if (!input.text)
+                    return { content: 'Error: text is required', isError: true };
+                if (webhookUrl) {
+                    const res = await fetch(webhookUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ channel: input.channel, text: input.text }),
+                    });
+                    return { content: `Message sent (status: ${res.status})` };
+                }
+                if (!token)
+                    return { content: 'Error: SLACK_BOT_TOKEN or SLACK_WEBHOOK_URL required', isError: true };
+                const res = await fetch('https://slack.com/api/chat.postMessage', {
+                    method: 'POST',
+                    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ channel: input.channel, text: input.text }),
+                });
+                const data = await res.json();
+                return { content: data.ok ? 'Message sent' : `Error: ${data.error}`, isError: !data.ok };
+            }
+            if (action === 'list_channels') {
+                if (!token)
+                    return { content: 'Error: SLACK_BOT_TOKEN required', isError: true };
+                const res = await fetch('https://slack.com/api/conversations.list', {
+                    headers: { 'Authorization': `Bearer ${token}` },
+                });
+                const data = await res.json();
+                return { content: JSON.stringify(data, null, 2) };
+            }
+            if (action === 'search') {
+                if (!token)
+                    return { content: 'Error: SLACK_BOT_TOKEN required', isError: true };
+                const res = await fetch(`https://slack.com/api/search.messages?query=${encodeURIComponent(String(input.text ?? ''))}`, {
+                    headers: { 'Authorization': `Bearer ${token}` },
+                });
+                const data = await res.json();
+                return { content: JSON.stringify(data, null, 2) };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `Slack error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=slack.js.map

package/dist/tools/integrations/summarizer.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const SummarizerTool: MCPTool;
+//# sourceMappingURL=summarizer.d.ts.map

package/dist/tools/integrations/summarizer.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummarizerTool = void 0;
+exports.SummarizerTool = {
+    name: 'summarizer',
+    description: 'Summarize long text using an LLM API. Requires OPENAI_API_KEY or LLM_API_URL env var.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            text: { type: 'string', description: 'Text to summarize' },
+            max_length: { type: 'number', description: 'Approximate max summary length in words (default: 200)' },
+            style: { type: 'string', enum: ['brief', 'detailed', 'bullets'], description: 'Summary style (default: brief)' },
+        },
+        required: ['text'],
+    },
+    async execute(input) {
+        const text = String(input.text ?? '');
+        if (!text)
+            return { content: 'Error: text required', isError: true };
+        const style = String(input.style ?? 'brief');
+        const maxLen = Number(input.max_length ?? 200);
+        const prompt = `Summarize the following text in a ${style} style, approximately ${maxLen} words:\n\n${text.slice(0, 15000)}`;
+        try {
+            const apiKey = process.env.OPENAI_API_KEY;
+            const apiUrl = process.env.LLM_API_URL || 'https://api.openai.com/v1/chat/completions';
+            if (!apiKey && apiUrl === 'https://api.openai.com/v1/chat/completions') {
+                return { content: 'Error: OPENAI_API_KEY or LLM_API_URL required', isError: true };
+            }
+            const headers = { 'Content-Type': 'application/json' };
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const res = await fetch(apiUrl, {
+                method: 'POST', headers,
+                body: JSON.stringify({
+                    model: process.env.LLM_MODEL || 'gpt-4o-mini',
+                    messages: [{ role: 'user', content: prompt }],
+                    max_tokens: maxLen * 3,
+                }),
+            });
+            const data = await res.json();
+            const summary = data.choices?.[0]?.message?.content ?? 'No summary generated';
+            return { content: summary };
+        }
+        catch (err) {
+            return { content: `Summarizer error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=summarizer.js.map

package/dist/tools/integrations/translator.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const TranslatorTool: MCPTool;
+//# sourceMappingURL=translator.d.ts.map

package/dist/tools/integrations/translator.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslatorTool = void 0;
+exports.TranslatorTool = {
+    name: 'translator',
+    description: 'Translate text between languages using an LLM. Requires OPENAI_API_KEY or LLM_API_URL env var.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            text: { type: 'string', description: 'Text to translate' },
+            from: { type: 'string', description: 'Source language (auto-detect if omitted)' },
+            to: { type: 'string', description: 'Target language (required)' },
+        },
+        required: ['text', 'to'],
+    },
+    async execute(input) {
+        const text = String(input.text ?? '');
+        const to = String(input.to ?? '');
+        if (!text || !to)
+            return { content: 'Error: text and to are required', isError: true };
+        const from = input.from ? ` from ${input.from}` : '';
+        const prompt = `Translate the following text${from} to ${to}. Return only the translation, no explanations:\n\n${text.slice(0, 10000)}`;
+        try {
+            const apiKey = process.env.OPENAI_API_KEY;
+            const apiUrl = process.env.LLM_API_URL || 'https://api.openai.com/v1/chat/completions';
+            if (!apiKey && apiUrl === 'https://api.openai.com/v1/chat/completions') {
+                return { content: 'Error: OPENAI_API_KEY or LLM_API_URL required', isError: true };
+            }
+            const headers = { 'Content-Type': 'application/json' };
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const res = await fetch(apiUrl, {
+                method: 'POST', headers,
+                body: JSON.stringify({
+                    model: process.env.LLM_MODEL || 'gpt-4o-mini',
+                    messages: [{ role: 'user', content: prompt }],
+                }),
+            });
+            const data = await res.json();
+            const translation = data.choices?.[0]?.message?.content ?? 'No translation generated';
+            return { content: translation };
+        }
+        catch (err) {
+            return { content: `Translation error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=translator.js.map

package/dist/tools/integrations/trello.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const TrelloTool: MCPTool;
+//# sourceMappingURL=trello.d.ts.map