confused-ai-core 0.1.0

package/src/tools/http-tool.ts

@@ -0,0 +1,118 @@
+/**
+ * HTTP client tool implementation
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * HTTP methods
+ */
+const HttpMethod = z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+type HttpMethod = z.infer<typeof HttpMethod>;
+
+/**
+ * Parameters for HTTP tool
+ */
+const HttpToolParameters = z.object({
+    url: z.string().url(),
+    method: HttpMethod.default('GET'),
+    headers: z.record(z.string(), z.string()).optional(),
+    body: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),
+    timeout: z.number().min(1000).max(60000).optional(),
+});
+
+/**
+ * HTTP response
+ */
+interface HttpResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+
+/**
+ * HTTP client tool for making web requests
+ */
+export class HttpClientTool extends BaseTool<typeof HttpToolParameters, HttpResponse> {
+    constructor(config?: Partial<Omit<BaseToolConfig<typeof HttpToolParameters>, 'parameters'>>) {
+        super({
+            name: config?.name ?? 'http.request',
+            description: config?.description ?? 'Make HTTP requests to external APIs and websites',
+            parameters: HttpToolParameters,
+            category: config?.category ?? ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            version: config?.version,
+            author: config?.author,
+            tags: config?.tags,
+        });
+    }
+
+    /**
+     * Execute HTTP request
+     */
+    protected async performExecute(
+        params: z.infer<typeof HttpToolParameters>,
+        _context: ToolContext
+    ): Promise<HttpResponse> {
+        const { url, method, headers, body, timeout } = params;
+
+        const fetchOptions: RequestInit = {
+            method,
+            headers: {
+                'Accept': 'application/json, text/plain, */*',
+                'User-Agent': 'AgentFramework/1.0',
+                ...headers,
+            },
+        };
+
+        if (body && method !== 'GET' && method !== 'HEAD') {
+            if (typeof body === 'string') {
+                fetchOptions.body = body;
+            } else {
+                fetchOptions.body = JSON.stringify(body);
+                fetchOptions.headers = {
+                    ...fetchOptions.headers,
+                    'Content-Type': 'application/json',
+                };
+            }
+        }
+
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout ?? 30000);
+
+        try {
+            const response = await fetch(url, {
+                ...fetchOptions,
+                signal: controller.signal,
+            });
+
+            clearTimeout(timeoutId);
+
+            // Convert headers
+            const responseHeaders: Record<string, string> = {};
+            response.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
+
+            // Get response body
+            const responseBody = await response.text();
+
+            return {
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                body: responseBody,
+            };
+        } catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+}

package/src/tools/index.ts

@@ -0,0 +1,99 @@
+/**
+ * Tools module exports
+ */
+
+// Core types and base classes
+export * from './types.js';
+export { ToolRegistryImpl, toToolRegistry, type ToolProvider } from './registry.js';
+export { BaseTool, type BaseToolConfig } from './base-tool.js';
+
+// Core tools
+export { HttpClientTool } from './http-tool.js';
+export { BrowserTool } from './browser-tool.js';
+export * from './file-tools.js';
+
+// Calculator tools
+export {
+    CalculatorAddTool,
+    CalculatorSubtractTool,
+    CalculatorMultiplyTool,
+    CalculatorDivideTool,
+    CalculatorExponentiateTool,
+    CalculatorFactorialTool,
+    CalculatorIsPrimeTool,
+    CalculatorSquareRootTool,
+    CalculatorToolkit,
+} from './calculator-tool.js';
+
+// Web search tools
+export {
+    DuckDuckGoSearchTool,
+    DuckDuckGoNewsTool,
+    WebSearchTool,
+    WebSearchToolkit,
+} from './websearch-tool.js';
+
+// Wikipedia tools
+export { WikipediaSearchTool, WikipediaToolkit } from './wikipedia-tool.js';
+
+// Shell tools
+export { ShellTool, ShellToolkit } from './shell-tool.js';
+
+// HackerNews tools
+export {
+    HackerNewsTopStoriesTool,
+    HackerNewsUserTool,
+    HackerNewsToolkit,
+} from './hackernews-tool.js';
+
+// Telegram tools
+export { TelegramTool, TelegramToolkit } from './telegram-tool.js';
+
+// GitHub tools
+export {
+    GitHubSearchRepositoriesTool,
+    GitHubGetRepositoryTool,
+    GitHubListIssuesTool,
+    GitHubCreateIssueTool,
+    GitHubListPullRequestsTool,
+    GitHubToolkit,
+} from './github-tool.js';
+
+// Slack tools
+export {
+    SlackSendMessageTool,
+    SlackListChannelsTool,
+    SlackGetChannelHistoryTool,
+    SlackToolkit,
+} from './slack-tool.js';
+
+// Jira tools
+export {
+    JiraGetIssueTool,
+    JiraCreateIssueTool,
+    JiraSearchIssuesTool,
+    JiraAddCommentTool,
+    JiraToolkit,
+} from './jira-tool.js';
+
+// Notion tools
+export {
+    NotionCreatePageTool,
+    NotionSearchTool,
+    NotionUpdatePageTool,
+    NotionToolkit,
+} from './notion-tool.js';
+
+// OpenAI tools
+export {
+    OpenAIGenerateImageTool,
+    OpenAITranscribeAudioTool,
+    OpenAIToolkit,
+} from './openai-tool.js';
+
+// SerpApi tools
+export {
+    SerpApiGoogleSearchTool,
+    SerpApiYouTubeSearchTool,
+    SerpApiToolkit,
+} from './serpapi-tool.js';

package/src/tools/jira-tool.ts

@@ -0,0 +1,373 @@
+/**
+ * Jira tool implementation - TypeScript JiraTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * Jira API types
+ */
+interface JiraIssue {
+    key: string;
+    fields: {
+        summary: string;
+        description?: string;
+        status: { name: string };
+        issuetype: { name: string };
+        assignee?: { displayName: string };
+        reporter?: { displayName: string };
+        project: { key: string };
+    };
+}
+
+interface JiraSearchResult {
+    issues: JiraIssue[];
+    total: number;
+}
+
+interface JiraResult {
+    data?: unknown;
+    error?: string;
+}
+
+/**
+ * Base Jira tool with common authentication
+ */
+abstract class BaseJiraTool<TParams extends z.ZodObject<Record<string, z.ZodType>>> extends BaseTool<TParams, JiraResult> {
+    protected serverUrl: string;
+    protected token: string;
+    protected email: string;
+
+    constructor(
+        config: Partial<Omit<BaseToolConfig<TParams>, 'parameters'>> & {
+            serverUrl?: string;
+            token?: string;
+            email?: string;
+        },
+        params: TParams
+    ) {
+        super({
+            name: config.name || 'jira.tool',
+            description: config.description || 'Jira tool',
+            parameters: params,
+            category: config.category || ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config.permissions,
+            },
+            ...config,
+        });
+
+        this.serverUrl = config.serverUrl || process.env.JIRA_SERVER_URL || '';
+        this.token = config.token || process.env.JIRA_TOKEN || '';
+        this.email = config.email || process.env.JIRA_EMAIL || '';
+
+        if (!this.serverUrl) {
+            throw new Error('Jira server URL is required. Set JIRA_SERVER_URL environment variable or pass serverUrl in config.');
+        }
+        if (!this.token) {
+            throw new Error('Jira API token is required. Set JIRA_TOKEN environment variable or pass token in config.');
+        }
+        if (!this.email) {
+            throw new Error('Jira email is required. Set JIRA_EMAIL environment variable or pass email in config.');
+        }
+    }
+
+    protected async jiraRequest(endpoint: string, options: RequestInit = {}): Promise<Response> {
+        const auth = Buffer.from(`${this.email}:${this.token}`).toString('base64');
+
+        return fetch(`${this.serverUrl}/rest/api/2${endpoint}`, {
+            ...options,
+            headers: {
+                Authorization: `Basic ${auth}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...(options.headers || {}),
+            },
+        });
+    }
+}
+
+/**
+ * Get issue tool
+ */
+const JiraGetIssueParameters = z.object({
+    issue_key: z.string().describe('The issue key (e.g., PROJ-123)'),
+});
+
+export class JiraGetIssueTool extends BaseJiraTool<typeof JiraGetIssueParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof JiraGetIssueParameters>, 'parameters'>> & {
+            serverUrl?: string;
+            token?: string;
+            email?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'jira.get_issue',
+                description: config?.description ?? 'Get details of a Jira issue',
+                ...config,
+            },
+            JiraGetIssueParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof JiraGetIssueParameters>,
+        _context: ToolContext
+    ): Promise<JiraResult> {
+        try {
+            const response = await this.jiraRequest(`/issue/${encodeURIComponent(params.issue_key)}`);
+
+            if (!response.ok) {
+                throw new Error(`Jira API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as JiraIssue;
+
+            return {
+                data: {
+                    key: data.key,
+                    summary: data.fields.summary,
+                    description: data.fields.description,
+                    status: data.fields.status.name,
+                    issueType: data.fields.issuetype.name,
+                    assignee: data.fields.assignee?.displayName,
+                    reporter: data.fields.reporter?.displayName,
+                    project: data.fields.project.key,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Create issue tool
+ */
+const JiraCreateIssueParameters = z.object({
+    project_key: z.string().describe('The project key (e.g., PROJ)'),
+    summary: z.string().describe('The issue summary/title'),
+    description: z.string().optional().describe('The issue description'),
+    issue_type: z.string().optional().default('Task').describe('The issue type (e.g., Task, Bug, Story)'),
+});
+
+export class JiraCreateIssueTool extends BaseJiraTool<typeof JiraCreateIssueParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof JiraCreateIssueParameters>, 'parameters'>> & {
+            serverUrl?: string;
+            token?: string;
+            email?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'jira.create_issue',
+                description: config?.description ?? 'Create a new Jira issue',
+                ...config,
+            },
+            JiraCreateIssueParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof JiraCreateIssueParameters>,
+        _context: ToolContext
+    ): Promise<JiraResult> {
+        try {
+            const body = {
+                fields: {
+                    project: { key: params.project_key },
+                    summary: params.summary,
+                    description: params.description,
+                    issuetype: { name: params.issue_type },
+                },
+            };
+
+            const response = await this.jiraRequest('/issue', {
+                method: 'POST',
+                body: JSON.stringify(body),
+            });
+
+            if (!response.ok) {
+                throw new Error(`Jira API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as { key: string; self: string };
+
+            return {
+                data: {
+                    key: data.key,
+                    url: `${this.serverUrl}/browse/${data.key}`,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Search issues tool
+ */
+const JiraSearchIssuesParameters = z.object({
+    jql: z.string().describe('JQL query string'),
+    max_results: z.number().min(1).max(100).optional().default(50).describe('Maximum number of results'),
+});
+
+export class JiraSearchIssuesTool extends BaseJiraTool<typeof JiraSearchIssuesParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof JiraSearchIssuesParameters>, 'parameters'>> & {
+            serverUrl?: string;
+            token?: string;
+            email?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'jira.search_issues',
+                description: config?.description ?? 'Search for issues using JQL',
+                ...config,
+            },
+            JiraSearchIssuesParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof JiraSearchIssuesParameters>,
+        _context: ToolContext
+    ): Promise<JiraResult> {
+        try {
+            const response = await this.jiraRequest(
+                `/search?jql=${encodeURIComponent(params.jql)}&maxResults=${params.max_results}`
+            );
+
+            if (!response.ok) {
+                throw new Error(`Jira API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as JiraSearchResult;
+
+            const issues = data.issues.map((issue) => ({
+                key: issue.key,
+                summary: issue.fields.summary,
+                status: issue.fields.status.name,
+                assignee: issue.fields.assignee?.displayName || 'Unassigned',
+            }));
+
+            return {
+                data: {
+                    total: data.total,
+                    issues,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Add comment tool
+ */
+const JiraAddCommentParameters = z.object({
+    issue_key: z.string().describe('The issue key'),
+    comment: z.string().describe('The comment text'),
+});
+
+export class JiraAddCommentTool extends BaseJiraTool<typeof JiraAddCommentParameters> {
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof JiraAddCommentParameters>, 'parameters'>> & {
+            serverUrl?: string;
+            token?: string;
+            email?: string;
+        }
+    ) {
+        super(
+            {
+                name: config?.name ?? 'jira.add_comment',
+                description: config?.description ?? 'Add a comment to a Jira issue',
+                ...config,
+            },
+            JiraAddCommentParameters
+        );
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof JiraAddCommentParameters>,
+        _context: ToolContext
+    ): Promise<JiraResult> {
+        try {
+            const response = await this.jiraRequest(`/issue/${encodeURIComponent(params.issue_key)}/comment`, {
+                method: 'POST',
+                body: JSON.stringify({ body: params.comment }),
+            });
+
+            if (!response.ok) {
+                throw new Error(`Jira API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as { id: string };
+
+            return {
+                data: {
+                    commentId: data.id,
+                    issueKey: params.issue_key,
+                },
+            };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Jira toolkit
+ */
+export class JiraToolkit {
+    static create(options?: {
+        serverUrl?: string;
+        token?: string;
+        email?: string;
+        enableGetIssue?: boolean;
+        enableCreateIssue?: boolean;
+        enableSearchIssues?: boolean;
+        enableAddComment?: boolean;
+    }): Array<JiraGetIssueTool | JiraCreateIssueTool | JiraSearchIssuesTool | JiraAddCommentTool> {
+        const tools: Array<JiraGetIssueTool | JiraCreateIssueTool | JiraSearchIssuesTool | JiraAddCommentTool> = [];
+
+        const config = {
+            serverUrl: options?.serverUrl,
+            token: options?.token,
+            email: options?.email,
+        };
+
+        if (options?.enableGetIssue !== false) {
+            tools.push(new JiraGetIssueTool(config));
+        }
+        if (options?.enableCreateIssue !== false) {
+            tools.push(new JiraCreateIssueTool(config));
+        }
+        if (options?.enableSearchIssues !== false) {
+            tools.push(new JiraSearchIssuesTool(config));
+        }
+        if (options?.enableAddComment !== false) {
+            tools.push(new JiraAddCommentTool(config));
+        }
+
+        return tools;
+    }
+}