confused-ai-core 0.1.0

package/src/tools/github-tool.ts

@@ -0,0 +1,432 @@
+/**
+ * GitHub tool implementation - TypeScript  GithubTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * GitHub API types
+ */
+interface GitHubRepository {
+    full_name: string;
+    description: string | null;
+    html_url: string;
+    stargazers_count: number;
+    forks_count: number;
+    language: string | null;
+    open_issues_count: number;
+    default_branch: string;
+    private: boolean;
+}
+
+interface GitHubIssue {
+    number: number;
+    title: string;
+    state: string;
+    html_url: string;
+    user: { login: string };
+    body: string | null;
+    labels: Array<{ name: string }>;
+}
+
+interface GitHubPullRequest {
+    number: number;
+    title: string;
+    state: string;
+    html_url: string;
+    user: { login: string };
+    body: string | null;
+    head: { ref: string };
+    base: { ref: string };
+}
+
+interface GitHubSearchResult {
+    items: Array<{
+        full_name: string;
+        description: string | null;
+        html_url: string;
+        stargazers_count: number;
+        forks_count: number;
+        language: string | null;
+    }>;
+    total_count: number;
+}
+
+interface GitHubResult {
+    data?: unknown;
+    error?: string;
+}
+
+// Base GitHub API URL
+const GITHUB_API_BASE = 'https://api.github.com';
+
+/**
+ * Helper function to make authenticated GitHub API requests
+ */
+async function githubRequest(
+    endpoint: string,
+    token?: string,
+    options: RequestInit = {}
+): Promise<Response> {
+    const headers: Record<string, string> = {
+        Accept: 'application/vnd.github.v3+json',
+        'User-Agent': 'AgentFramework/1.0',
+        ...((options.headers as Record<string, string>) || {}),
+    };
+
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+
+    return fetch(`${GITHUB_API_BASE}${endpoint}`, {
+        ...options,
+        headers,
+    });
+}
+
+/**
+ * Search repositories tool
+ */
+const GitHubSearchRepositoriesParameters = z.object({
+    query: z.string().describe('Search query for repositories'),
+    sort: z.enum(['stars', 'forks', 'updated']).optional().default('stars'),
+    order: z.enum(['asc', 'desc']).optional().default('desc'),
+    per_page: z.number().min(1).max(100).optional().default(30),
+});
+
+export class GitHubSearchRepositoriesTool extends BaseTool<typeof GitHubSearchRepositoriesParameters, GitHubResult> {
+    private token?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof GitHubSearchRepositoriesParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'github.search_repositories',
+            description: config?.description ?? 'Search for repositories on GitHub',
+            parameters: GitHubSearchRepositoriesParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.token = config?.token || process.env.GITHUB_ACCESS_TOKEN;
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof GitHubSearchRepositoriesParameters>,
+        _context: ToolContext
+    ): Promise<GitHubResult> {
+        try {
+            const response = await githubRequest(
+                `/search/repositories?q=${encodeURIComponent(params.query)}&sort=${params.sort}&order=${params.order}&per_page=${params.per_page}`,
+                this.token
+            );
+
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as GitHubSearchResult;
+            return { data };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Get repository tool
+ */
+const GitHubGetRepositoryParameters = z.object({
+    owner: z.string().describe('Repository owner (username or organization)'),
+    repo: z.string().describe('Repository name'),
+});
+
+export class GitHubGetRepositoryTool extends BaseTool<typeof GitHubGetRepositoryParameters, GitHubResult> {
+    private token?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof GitHubGetRepositoryParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'github.get_repository',
+            description: config?.description ?? 'Get details of a specific repository',
+            parameters: GitHubGetRepositoryParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.token = config?.token || process.env.GITHUB_ACCESS_TOKEN;
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof GitHubGetRepositoryParameters>,
+        _context: ToolContext
+    ): Promise<GitHubResult> {
+        try {
+            const response = await githubRequest(
+                `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}`,
+                this.token
+            );
+
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as GitHubRepository;
+            return { data };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * List issues tool
+ */
+const GitHubListIssuesParameters = z.object({
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    state: z.enum(['open', 'closed', 'all']).optional().default('open'),
+    per_page: z.number().min(1).max(100).optional().default(30),
+});
+
+export class GitHubListIssuesTool extends BaseTool<typeof GitHubListIssuesParameters, GitHubResult> {
+    private token?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof GitHubListIssuesParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'github.list_issues',
+            description: config?.description ?? 'List issues in a repository',
+            parameters: GitHubListIssuesParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.token = config?.token || process.env.GITHUB_ACCESS_TOKEN;
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof GitHubListIssuesParameters>,
+        _context: ToolContext
+    ): Promise<GitHubResult> {
+        try {
+            const response = await githubRequest(
+                `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/issues?state=${params.state}&per_page=${params.per_page}`,
+                this.token
+            );
+
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as GitHubIssue[];
+            return { data };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * Create issue tool
+ */
+const GitHubCreateIssueParameters = z.object({
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    title: z.string().describe('Issue title'),
+    body: z.string().optional().describe('Issue body/description'),
+    labels: z.array(z.string()).optional().describe('Labels to apply to the issue'),
+});
+
+export class GitHubCreateIssueTool extends BaseTool<typeof GitHubCreateIssueParameters, GitHubResult> {
+    private token?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof GitHubCreateIssueParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'github.create_issue',
+            description: config?.description ?? 'Create a new issue in a repository',
+            parameters: GitHubCreateIssueParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.token = config?.token || process.env.GITHUB_ACCESS_TOKEN;
+
+        if (!this.token) {
+            throw new Error('GitHub access token is required for creating issues');
+        }
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof GitHubCreateIssueParameters>,
+        _context: ToolContext
+    ): Promise<GitHubResult> {
+        try {
+            const response = await githubRequest(
+                `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/issues`,
+                this.token,
+                {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        title: params.title,
+                        body: params.body,
+                        labels: params.labels,
+                    }),
+                }
+            );
+
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as GitHubIssue;
+            return { data };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * List pull requests tool
+ */
+const GitHubListPullRequestsParameters = z.object({
+    owner: z.string().describe('Repository owner'),
+    repo: z.string().describe('Repository name'),
+    state: z.enum(['open', 'closed', 'all']).optional().default('open'),
+    per_page: z.number().min(1).max(100).optional().default(30),
+});
+
+export class GitHubListPullRequestsTool extends BaseTool<typeof GitHubListPullRequestsParameters, GitHubResult> {
+    private token?: string;
+
+    constructor(
+        config?: Partial<Omit<BaseToolConfig<typeof GitHubListPullRequestsParameters>, 'parameters'>> & {
+            token?: string;
+        }
+    ) {
+        super({
+            name: config?.name ?? 'github.list_pull_requests',
+            description: config?.description ?? 'List pull requests in a repository',
+            parameters: GitHubListPullRequestsParameters,
+            category: config?.category ?? ToolCategory.API,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+        this.token = config?.token || process.env.GITHUB_ACCESS_TOKEN;
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof GitHubListPullRequestsParameters>,
+        _context: ToolContext
+    ): Promise<GitHubResult> {
+        try {
+            const response = await githubRequest(
+                `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/pulls?state=${params.state}&per_page=${params.per_page}`,
+                this.token
+            );
+
+            if (!response.ok) {
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+
+            const data = (await response.json()) as GitHubPullRequest[];
+            return { data };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * GitHub toolkit
+ */
+export class GitHubToolkit {
+    static create(options?: {
+        token?: string;
+        enableSearch?: boolean;
+        enableGetRepo?: boolean;
+        enableListIssues?: boolean;
+        enableCreateIssue?: boolean;
+        enableListPRs?: boolean;
+    }): Array<
+        | GitHubSearchRepositoriesTool
+        | GitHubGetRepositoryTool
+        | GitHubListIssuesTool
+        | GitHubCreateIssueTool
+        | GitHubListPullRequestsTool
+    > {
+        const tools: Array<
+            | GitHubSearchRepositoriesTool
+            | GitHubGetRepositoryTool
+            | GitHubListIssuesTool
+            | GitHubCreateIssueTool
+            | GitHubListPullRequestsTool
+        > = [];
+
+        if (options?.enableSearch !== false) {
+            tools.push(new GitHubSearchRepositoriesTool({ token: options?.token }));
+        }
+        if (options?.enableGetRepo !== false) {
+            tools.push(new GitHubGetRepositoryTool({ token: options?.token }));
+        }
+        if (options?.enableListIssues !== false) {
+            tools.push(new GitHubListIssuesTool({ token: options?.token }));
+        }
+        if (options?.enableCreateIssue !== false) {
+            tools.push(new GitHubCreateIssueTool({ token: options?.token }));
+        }
+        if (options?.enableListPRs !== false) {
+            tools.push(new GitHubListPullRequestsTool({ token: options?.token }));
+        }
+
+        return tools;
+    }
+}

package/src/tools/hackernews-tool.ts

@@ -0,0 +1,187 @@
+/**
+ * HackerNews tool implementation - TypeScript  HackerNewsTools
+ */
+
+import { z } from 'zod';
+import { BaseTool, BaseToolConfig } from './base-tool.js';
+import { ToolContext, ToolCategory } from './types.js';
+
+/**
+ * HackerNews story
+ */
+interface HackerNewsStory {
+    id: number;
+    title?: string;
+    url?: string;
+    score?: number;
+    by?: string;
+    time?: number;
+    descendants?: number;
+    type: string;
+    username?: string;
+}
+
+/**
+ * HackerNews user details
+ */
+interface HackerNewsUser {
+    id?: string;
+    karma?: number;
+    about?: string;
+    total_items_submitted?: number;
+}
+
+interface HackerNewsResult {
+    stories?: HackerNewsStory[];
+    user?: HackerNewsUser;
+    error?: string;
+}
+
+/**
+ * Parameters for getting top stories
+ */
+const HackerNewsTopStoriesParameters = z.object({
+    num_stories: z.number().min(1).max(50).optional().default(10).describe('Number of stories to return'),
+});
+
+/**
+ * Parameters for getting user details
+ */
+const HackerNewsUserParameters = z.object({
+    username: z.string().describe('Username of the Hacker News user'),
+});
+
+/**
+ * HackerNews top stories tool
+ */
+export class HackerNewsTopStoriesTool extends BaseTool<typeof HackerNewsTopStoriesParameters, HackerNewsResult> {
+    constructor(config?: Partial<Omit<BaseToolConfig<typeof HackerNewsTopStoriesParameters>, 'parameters'>>) {
+        super({
+            name: config?.name ?? 'hackernews.top_stories',
+            description: config?.description ?? 'Get top stories from Hacker News',
+            parameters: HackerNewsTopStoriesParameters,
+            category: config?.category ?? ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof HackerNewsTopStoriesParameters>,
+        _context: ToolContext
+    ): Promise<HackerNewsResult> {
+        try {
+            // Fetch top story IDs
+            const response = await fetch('https://hacker-news.firebaseio.com/v0/topstories.json');
+
+            if (!response.ok) {
+                throw new Error(`Failed to fetch top stories: ${response.status}`);
+            }
+
+            const storyIds = (await response.json()) as number[];
+            const topIds = storyIds.slice(0, params.num_stories);
+
+            // Fetch story details
+            const stories: HackerNewsStory[] = [];
+            for (const storyId of topIds) {
+                try {
+                    const storyResponse = await fetch(`https://hacker-news.firebaseio.com/v0/item/${storyId}.json`);
+                    if (storyResponse.ok) {
+                        const story = (await storyResponse.json()) as HackerNewsStory;
+                        story.username = story.by;
+                        stories.push(story);
+                    }
+                } catch {
+                    // Skip failed story fetches
+                }
+            }
+
+            return { stories };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * HackerNews user details tool
+ */
+export class HackerNewsUserTool extends BaseTool<typeof HackerNewsUserParameters, HackerNewsResult> {
+    constructor(config?: Partial<Omit<BaseToolConfig<typeof HackerNewsUserParameters>, 'parameters'>>) {
+        super({
+            name: config?.name ?? 'hackernews.user_details',
+            description: config?.description ?? 'Get details of a Hacker News user',
+            parameters: HackerNewsUserParameters,
+            category: config?.category ?? ToolCategory.WEB,
+            permissions: {
+                allowNetwork: true,
+                maxExecutionTimeMs: 30000,
+                ...config?.permissions,
+            },
+            ...config,
+        });
+    }
+
+    protected async performExecute(
+        params: z.infer<typeof HackerNewsUserParameters>,
+        _context: ToolContext
+    ): Promise<HackerNewsResult> {
+        try {
+            const response = await fetch(`https://hacker-news.firebaseio.com/v0/user/${params.username}.json`);
+
+            if (!response.ok) {
+                throw new Error(`Failed to fetch user details: ${response.status}`);
+            }
+
+            const userData = (await response.json()) as {
+                id?: string;
+                karma?: number;
+                about?: string;
+                submitted?: number[];
+            };
+
+            if (!userData) {
+                return {
+                    error: `User ${params.username} not found`,
+                };
+            }
+
+            const user: HackerNewsUser = {
+                id: userData.id,
+                karma: userData.karma,
+                about: userData.about,
+                total_items_submitted: userData.submitted?.length || 0,
+            };
+
+            return { user };
+        } catch (error) {
+            return {
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+}
+
+/**
+ * HackerNews toolkit
+ */
+export class HackerNewsToolkit {
+    static create(options?: { enableTopStories?: boolean; enableUserDetails?: boolean }): Array<HackerNewsTopStoriesTool | HackerNewsUserTool> {
+        const tools: Array<HackerNewsTopStoriesTool | HackerNewsUserTool> = [];
+
+        if (options?.enableTopStories !== false) {
+            tools.push(new HackerNewsTopStoriesTool());
+        }
+        if (options?.enableUserDetails !== false) {
+            tools.push(new HackerNewsUserTool());
+        }
+
+        return tools;
+    }
+}