confused-ai-core 0.1.0

package/src/tools/serpapi-tool.ts

@@ -0,0 +1,234 @@
+/**
+ * SerpApi tool implementation - TypeScript SerpApiTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * SerpApi result types
+ */
+interface SerpApiSearchResult {
+    title?: string;
+    link?: string;
+    snippet?: string;
+    displayed_link?: string;
+}
+
+interface SerpApiVideoResult {
+    title?: string;
+    link?: string;
+    snippet?: string;
+    thumbnail?: string;
+    duration?: string;
+}
+
+interface SerpApiChannelResult {
+    title?: string;
+    link?: string;
+    thumbnail?: string;
+}
+
+interface SerpApiResult {
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Base SerpApi tool with common authentication
+ */
+abstract class BaseSerpApiTool<TParams extends z.ZodObject<Record<string, z.ZodType>>> extends BaseTool<TParams, SerpApiResult> {
+    protected apiKey: string;
+    protected baseUrl = 'https://serpapi.com/search';
+
+    constructor(
+        config: Partial<Omit<BaseToolConfig<TParams>, 'parameters'>> & {
+            apiKey?: string;
+        },
+        params: TParams
+    ) {
+        super({
+            name: config.name || 'serpapi.tool',
+            description: config.description || 'SerpApi tool',
+            parameters: params,
+            category: config.category || ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config.permissions,
+            },
+            ...config,
+        });
+
+        this.apiKey = config.apiKey || process.env.SERPAPI_API_KEY || '';
+
+        if (!this.apiKey) {
+            throw new Error('SerpApi API key is required. Set SERPAPI_API_KEY environment variable or pass apiKey in config.');
+        }
+    }
+
+    protected async serpApiRequest(params: Record<string, string>): Promise<Response> {
+        const queryParams = new URLSearchParams({
+            api_key: this.apiKey,
+            ...params,
+        });
+
+        return fetch(`${this.baseUrl}?${queryParams.toString()}`);
+    }
+}
+
+/**
+ * Google search tool
+ */
+const SerpApiGoogleSearchParameters = z.object({
+    query: z.string().describe('The search query'),
+    num_results: z.number().min(1).max(100).optional().default(10).describe('Number of results to return'),
+});
+
+export class SerpApiGoogleSearchTool extends BaseSerpApiTool<typeof SerpApiGoogleSearchParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof SerpApiGoogleSearchParameters>, 'parameters'>> & {
+            apiKey?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'serpapi.google_search',
+                description: config?.description ?? 'Search Google using SerpApi',
+                ...config,
+            },
+            SerpApiGoogleSearchParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof SerpApiGoogleSearchParameters>,
+        _context: ToolContext
+    ): Promise<SerpApiResult> {
+        try {
+            const response = await this.serpApiRequest({
+                engine: 'google',
+                q: params.query,
+                num: params.num_results.toString(),
+            });
+
+            if (!response.ok) {
+                throw new Error(`SerpApi error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as {
+                organic_results?: SerpApiSearchResult[];
+                knowledge_graph?: unknown;
+                related_questions?: unknown[];
+            };
+
+            return {
+                data: {
+                    search_results: (data.organic_results || []).map((result) => ({
+                        title: result.title,
+                        url: result.link,
+                        snippet: result.snippet,
+                        displayed_link: result.displayed_link,
+                    })),
+                    knowledge_graph: data.knowledge_graph,
+                    related_questions: data.related_questions,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * YouTube search tool
+ */
+const SerpApiYouTubeSearchParameters = z.object({
+    query: z.string().describe('The search query'),
+    num_results: z.number().min(1).max(50).optional().default(10).describe('Number of results to return'),
+});
+
+export class SerpApiYouTubeSearchTool extends BaseSerpApiTool<typeof SerpApiYouTubeSearchParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof SerpApiYouTubeSearchParameters>, 'parameters'>> & {
+            apiKey?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'serpapi.youtube_search',
+                description: config?.description ?? 'Search YouTube using SerpApi',
+                ...config,
+            },
+            SerpApiYouTubeSearchParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof SerpApiYouTubeSearchParameters>,
+        _context: ToolContext
+    ): Promise<SerpApiResult> {
+        try {
+            const response = await this.serpApiRequest({
+                engine: 'youtube',
+                search_query: params.query,
+                num: params.num_results.toString(),
+            });
+
+            if (!response.ok) {
+                throw new Error(`SerpApi error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as {
+                video_results?: SerpApiVideoResult[];
+                channel_results?: SerpApiChannelResult[];
+            };
+
+            return {
+                data: {
+                    video_results: (data.video_results || []).map((result) => ({
+                        title: result.title,
+                        url: result.link,
+                        snippet: result.snippet,
+                        thumbnail: result.thumbnail,
+                        duration: result.duration,
+                    })),
+                    channel_results: (data.channel_results || []).map((result) => ({
+                        title: result.title,
+                        url: result.link,
+                        thumbnail: result.thumbnail,
+                    })),
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * SerpApi toolkit
+ */
+export class SerpApiToolkit {
+    static create(options?: {
+        apiKey?: string;
+        enableGoogleSearch?: boolean;
+        enableYouTubeSearch?: boolean;
+    }): Array<SerpApiGoogleSearchTool | SerpApiYouTubeSearchTool> {
+        const tools: Array<SerpApiGoogleSearchTool | SerpApiYouTubeSearchTool> = [];
+
+        if (options?.enableGoogleSearch !== false) {
+            tools.push(new SerpApiGoogleSearchTool({ apiKey: options?.apiKey }));
+        }
+        if (options?.enableYouTubeSearch !== false) {
+            tools.push(new SerpApiYouTubeSearchTool({ apiKey: options?.apiKey }));
+        }
+
+        return tools;
+    }
+}

package/src/tools/shell-tool.ts

@@ -0,0 +1,118 @@
+/**
+ * Shell tool implementation - TypeScript  ShellTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+
+const execAsync = promisify(exec);
+
+/**
+ * Shell command result
+ */
+interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    error?: string;
+}
+
+/**
+ * Parameters for shell command execution
+ */
+const ShellCommandParameters = z.object({
+    command: z.string().describe('The shell command to execute'),
+    cwd: z.string().optional().describe('Working directory for the command (optional)'),
+    timeout: z.number().min(1000).max(300000).optional().default(30000).describe('Timeout in milliseconds'),
+});
+
+/**
+ * Shell tool for running shell commands
+ */
+export class ShellTool extends BaseTool<typeof ShellCommandParameters, ShellResult> {
+    private baseDir?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof ShellCommandParameters>, 'parameters'>> & {
+            baseDir?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'shell.run',
+            description: config?.description ?? 'Run a shell command and return the output',
+            parameters: ShellCommandParameters,
+            category: config?.category ?? ToolCategory.UTILITY,
+            permissions: {
+                allowNetwork: false,
+                allowFileSystem: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.baseDir = config?.baseDir;
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof ShellCommandParameters>,
+        _context: ToolContext
+    ): Promise<ShellResult> {
+        const cwd = params.cwd || this.baseDir || process.cwd();
+
+        // Validate the working directory is safe
+        const resolvedCwd = path.resolve(cwd);
+        const resolvedBase = this.baseDir ? path.resolve(this.baseDir) : resolvedCwd;
+
+        if (this.baseDir && !resolvedCwd.startsWith(resolvedBase)) {
+            return {
+                stdout: '',
+                stderr: '',
+                exitCode: 1,
+                error: `Working directory ${cwd} is outside the allowed base directory`,
+            };
+        }
+
+        try {
+            const { stdout, stderr } = await execAsync(params.command, {
+                cwd: resolvedCwd,
+                timeout: params.timeout,
+                maxBuffer: 1024 * 1024, // 1MB buffer
+            });
+
+            return {
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                exitCode: 0,
+            };
+        } catch (error) {
+            if (error instanceof Error && 'stdout' in error && 'stderr' in error) {
+                const execError = error as unknown as { stdout: string; stderr: string; code?: number };
+                return {
+                    stdout: execError.stdout?.trim() || '',
+                    stderr: execError.stderr?.trim() || '',
+                    exitCode: execError.code ?? 1,
+                };
+            }
+
+            return {
+                stdout: '',
+                stderr: '',
+                exitCode: 1,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Shell toolkit
+ */
+export class ShellToolkit {
+    static create(options?: { baseDir?: string }): Array<ShellTool> {
+        return [new ShellTool({ baseDir: options?.baseDir })];
+    }
+}

package/src/tools/slack-tool.ts

@@ -0,0 +1,327 @@
+/**
+ * Slack tool implementation - TypeScript SlackTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * Slack API response types
+ */
+interface SlackPostMessageResponse {
+    ok: boolean;
+    channel?: string;
+    ts?: string;
+    message?: unknown;
+    error?: string;
+}
+
+interface SlackChannel {
+    id: string;
+    name: string;
+}
+
+interface SlackChannelsResponse {
+    ok: boolean;
+    channels?: SlackChannel[];
+    error?: string;
+}
+
+interface SlackMessage {
+    text?: string;
+    user?: string;
+    ts?: string;
+    subtype?: string;
+    bot_id?: string;
+    attachments?: unknown[];
+}
+
+interface SlackHistoryResponse {
+    ok: boolean;
+    messages?: SlackMessage[];
+    error?: string;
+}
+
+interface SlackResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Parameters for sending a Slack message
+ */
+const SlackSendMessageParameters = z.object({
+    channel: z.string().describe('The channel ID or name to send the message to'),
+    text: z.string().describe('The text of the message to send'),
+    thread_ts: z.string().optional().describe('Timestamp of the parent message (for threaded replies)'),
+});
+
+/**
+ * Slack send message tool
+ */
+export class SlackSendMessageTool extends BaseTool<typeof SlackSendMessageParameters, SlackResult> {
+    private token: string;
+    private baseUrl = 'https://slack.com/api';
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof SlackSendMessageParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'slack.send_message',
+            description: config?.description ?? 'Send a message to a Slack channel',
+            parameters: SlackSendMessageParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+
+        this.token = config?.token || process.env.SLACK_TOKEN || '';
+
+        if (!this.token) {
+            throw new Error('Slack token is required. Set SLACK_TOKEN environment variable or pass token in config.');
+        }
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof SlackSendMessageParameters>,
+        _context: ToolContext
+    ): Promise<SlackResult> {
+        try {
+            const body: Record<string, string> = {
+                channel: params.channel,
+                text: params.text,
+            };
+
+            if (params.thread_ts) {
+                body.thread_ts = params.thread_ts;
+            }
+
+            const response = await fetch(`${this.baseUrl}/chat.postMessage`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+
+            const data = (await response.json()) as SlackPostMessageResponse;
+
+            if (data.ok) {
+                return {
+                    success: true,
+                    data: {
+                        channel: data.channel,
+                        ts: data.ts,
+                        message: data.message,
+                    },
+                };
+            } else {
+                return {
+                    success: false,
+                    error: data.error || 'Unknown Slack API error',
+                };
+            }
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Parameters for listing Slack channels
+ */
+const SlackListChannelsParameters = z.object({
+    limit: z.number().min(1).max(200).optional().default(100).describe('Maximum number of channels to return'),
+});
+
+/**
+ * Slack list channels tool
+ */
+export class SlackListChannelsTool extends BaseTool<typeof SlackListChannelsParameters, SlackResult> {
+    private token: string;
+    private baseUrl = 'https://slack.com/api';
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof SlackListChannelsParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'slack.list_channels',
+            description: config?.description ?? 'List all channels in the Slack workspace',
+            parameters: SlackListChannelsParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+
+        this.token = config?.token || process.env.SLACK_TOKEN || '';
+
+        if (!this.token) {
+            throw new Error('Slack token is required. Set SLACK_TOKEN environment variable or pass token in config.');
+        }
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof SlackListChannelsParameters>,
+        _context: ToolContext
+    ): Promise<SlackResult> {
+        try {
+            const response = await fetch(`${this.baseUrl}/conversations.list?limit=${params.limit}`, {
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                },
+            });
+
+            const data = (await response.json()) as SlackChannelsResponse;
+
+            if (data.ok) {
+                const channels = (data.channels || []).map((channel) => ({
+                    id: channel.id,
+                    name: channel.name,
+                }));
+
+                return {
+                    success: true,
+                    data: channels,
+                };
+            } else {
+                return {
+                    success: false,
+                    error: data.error || 'Unknown Slack API error',
+                };
+            }
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Parameters for getting channel history
+ */
+const SlackGetChannelHistoryParameters = z.object({
+    channel: z.string().describe('The channel ID to fetch history from'),
+    limit: z.number().min(1).max(200).optional().default(100).describe('Maximum number of messages to return'),
+});
+
+/**
+ * Slack get channel history tool
+ */
+export class SlackGetChannelHistoryTool extends BaseTool<typeof SlackGetChannelHistoryParameters, SlackResult> {
+    private token: string;
+    private baseUrl = 'https://slack.com/api';
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof SlackGetChannelHistoryParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'slack.get_channel_history',
+            description: config?.description ?? 'Get the message history of a Slack channel',
+            parameters: SlackGetChannelHistoryParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+
+        this.token = config?.token || process.env.SLACK_TOKEN || '';
+
+        if (!this.token) {
+            throw new Error('Slack token is required. Set SLACK_TOKEN environment variable or pass token in config.');
+        }
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof SlackGetChannelHistoryParameters>,
+        _context: ToolContext
+    ): Promise<SlackResult> {
+        try {
+            const response = await fetch(
+                `${this.baseUrl}/conversations.history?channel=${encodeURIComponent(params.channel)}&limit=${params.limit}`,
+                {
+                    headers: {
+                        Authorization: `Bearer ${this.token}`,
+                    },
+                }
+            );
+
+            const data = (await response.json()) as SlackHistoryResponse;
+
+            if (data.ok) {
+                const messages = (data.messages || []).map((msg) => ({
+                    text: msg.text,
+                    user: msg.user || (msg.bot_id ? 'bot' : 'unknown'),
+                    ts: msg.ts,
+                    subtype: msg.subtype || 'normal',
+                    attachments: msg.attachments,
+                }));
+
+                return {
+                    success: true,
+                    data: messages,
+                };
+            } else {
+                return {
+                    success: false,
+                    error: data.error || 'Unknown Slack API error',
+                };
+            }
+        } catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Slack toolkit
+ */
+export class SlackToolkit {
+    static create(options?: {
+        token?: string;
+        enableSendMessage?: boolean;
+        enableListChannels?: boolean;
+        enableGetHistory?: boolean;
+    }): Array<SlackSendMessageTool | SlackListChannelsTool | SlackGetChannelHistoryTool> {
+        const tools: Array<SlackSendMessageTool | SlackListChannelsTool | SlackGetChannelHistoryTool> = [];
+
+        if (options?.enableSendMessage !== false) {
+            tools.push(new SlackSendMessageTool({ token: options?.token }));
+        }
+        if (options?.enableListChannels !== false) {
+            tools.push(new SlackListChannelsTool({ token: options?.token }));
+        }
+        if (options?.enableGetHistory !== false) {
+            tools.push(new SlackGetChannelHistoryTool({ token: options?.token }));
+        }
+
+        return tools;
+    }
+}