@feedmob/github-issues 0.0.2 → 0.0.3

package/README.md

@@ -1,125 +1,86 @@
-# GitHub MCP Server
+# FeedMob GitHub Issues MCP Server
 
-MCP Server for the GitHub API, enabling issue operations and search functionality.
-
-## Features
-
-The GitHub MCP Server provides the following capabilities:
-- Create and manage GitHub issues
-- Search for issues across repositories
-- List and filter repository issues
-- Update existing issues
-- Get details of specific issues
+A GitHub Issues MCP server customized for the FeedMob team
 
 ## Tools
 
+### `search_issues`
+- Search GitHub Issues through FeedMob API
+- Input parameters:
+  - `scheam` (string, required): Get from system resource `issues/search_schema`
+  - `start_date` (string): Issue creation start date, defaults to 6 days ago
+  - `end_date` (string): Issue creation end date, defaults to today
+  - `status` (optional string): Issue status, e.g., 'open', 'closed'
+  - `repo` (optional string)
+  - `users` (optional string[]): List of users
+  - `team` (optional string): Team name, e.g., 'Star', 'Mighty'
+- Returns: Search results
+
 ### `create_issue`
-- Create a new issue in a GitHub repository
-- Inputs:
-  - `owner` (string): Repository owner
-  - `repo` (string): Repository name
-  - `title` (string): Issue title
+- Create a new Issue in a GitHub repository
+- Input parameters:
+  - `owner` (optional string): Repository owner, can use environment variable default
+  - `repo` (string, required): Repository name
+  - `title` (string, required): Issue title
   - `body` (optional string): Issue description
-  - `assignees` (optional string[]): Usernames to assign
+  - `assignees` (optional string[]): Usernames to assign to
   - `labels` (optional string[]): Labels to add
   - `milestone` (optional number): Milestone number
-- Returns: Created issue details
-
-### `list_issues`
-- List and filter repository issues
-- Inputs:
-  - `owner` (string): Repository owner
-  - `repo` (string): Repository name
-  - `state` (optional string): Filter by state ('open', 'closed', 'all')
-  - `labels` (optional string[]): Filter by labels
-  - `sort` (optional string): Sort by ('created', 'updated', 'comments')
-  - `direction` (optional string): Sort direction ('asc', 'desc')
-  - `since` (optional string): Filter by date (ISO 8601 timestamp)
-  - `page` (optional number): Page number
-  - `per_page` (optional number): Results per page
-- Returns: Array of issue details
+- Returns: Created Issue details
 
 ### `update_issue`
-- Update an existing issue
-- Inputs:
-  - `owner` (string): Repository owner
-  - `repo` (string): Repository name
-  - `issue_number` (number): Issue number to update
+- Update an existing Issue
+- Input parameters:
+  - `owner` (string, required): Repository owner
+  - `repo` (string, required): Repository name
+  - `issue_number` (number, required): Issue number to update
   - `title` (optional string): New title
   - `body` (optional string): New description
   - `state` (optional string): New state ('open' or 'closed')
   - `labels` (optional string[]): New labels
   - `assignees` (optional string[]): New assignees
   - `milestone` (optional number): New milestone number
-- Returns: Updated issue details
-
-### `search_issues`
-- Search for issues and pull requests across GitHub repositories
-- Inputs:
-  - `q` (string): Search query using GitHub issues search syntax
-  - `sort` (optional string): Sort field (comments, reactions, created, etc.)
-  - `order` (optional string): Sort order ('asc' or 'desc')
-  - `per_page` (optional number): Results per page (max 100)
-  - `page` (optional number): Page number
-- Returns: Issue and pull request search results
+- Returns: Updated Issue details
 
 ### `get_issue`
-- Gets the contents of an issue within a repository
-- Inputs:
-  - `owner` (string): Repository owner
-  - `repo` (string): Repository name
-  - `issue_number` (number): Issue number to retrieve
-- Returns: GitHub Issue object & details
-
-## Search Query Syntax
-
-### Issues Search
-- `is:issue` or `is:pr`: Filter by type
-- `is:open` or `is:closed`: Filter by state
-- `label:bug`: Search by label
-- `author:username`: Search by author
-- Example: `q: "memory leak" is:issue is:open label:bug`
-
-For detailed search syntax, see [GitHub's searching documentation](https://docs.github.com/en/search-github/searching-on-github).
-
-## Setup
-
-### Environment Variables
-This server supports the following environment variables:
-- `GITHUB_PERSONAL_ACCESS_TOKEN`: Your GitHub Personal Access Token (required)
-- `GITHUB_DEFAULT_OWNER`: Default repository owner (optional)
-- `GITHUB_DEFAULT_REPO`: Default repository name (optional)
-
-### Personal Access Token
-[Create a GitHub Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with appropriate permissions:
-   - Go to [Personal access tokens](https://github.com/settings/tokens) (in GitHub Settings > Developer settings)
-   - Select which repositories you'd like this token to have access to (Public, All, or Select)
-   - Create a token with the `repo` scope ("Full control of private repositories")
-     - Alternatively, if working only with public repositories, select only the `public_repo` scope
-   - Copy the generated token
-
-### Usage with Claude Desktop
-To use this with Claude Desktop, add the following to your `claude_desktop_config.json`:
-
-```json
-{
-  "mcpServers": {
-    "github": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@feedmob/github-issues"
-      ],
-      "env": {
-        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>",
-        "GITHUB_DEFAULT_OWNER": "optional-default-owner",
-        "GITHUB_DEFAULT_REPO": "optional-default-repo"
-      }
-    }
-  }
-}
+- Get details of a specific Issue in a repository
+- Input parameters:
+  - `owner` (string, required): Repository owner
+  - `repo` (string, required):
+  - `issue_number` (number, required): Issue number to retrieve
+- Returns: GitHub Issue object and details
+
+### `add_issue_comment`
+- Add a comment to an existing Issue
+- Input parameters:
+  - `owner` (string, required): Repository owner
+  - `repo` (string, required):
+  - `issue_number` (number, required): Issue number
+  - `body` (string, required): Comment content
+- Returns: Created comment details
+
+### `sync_latest_issues`
+- Sync GitHub Issues Latest Data By FeedMob API
+
+## Resources
+
+### `issues/search_schema`
+- Provides schema definition for Issues search
+
+### Local Development
+For local development, you can run the server using the following commands:
+
+```bash
+# Install dependencies
+npm install
+
+# Build project
+npm run build
+
+# Run server
+npx tsx src/github-issues/index.ts
 ```
 
 ## License
 
-This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
+This MCP server is licensed under the MIT License. This means you can freely use, modify, and distribute this software, but must comply with the terms and conditions of the MIT License. For more details, please refer to the LICENSE file in the project repository.

package/dist/common/version.js

@@ -1,3 +1,3 @@
 // If the format of this file changes, so it doesn't simply export a VERSION constant,
 // this will break .github/workflows/version-check.yml.
-export const VERSION = "0.0.2";
+export const VERSION = "0.0.3";

package/dist/index.js

@@ -1,28 +1,20 @@
 #!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { FastMCP } from "fastmcp";
 import fetch from 'node-fetch';
 import * as issues from './operations/issues.js';
-import * as search from './operations/search.js';
-import { GitHubValidationError, GitHubResourceNotFoundError, GitHubAuthenticationError, GitHubPermissionError, GitHubRateLimitError, GitHubConflictError, isGitHubError, } from './common/errors.js';
+import { GitHubValidationError, GitHubResourceNotFoundError, GitHubAuthenticationError, GitHubPermissionError, GitHubRateLimitError, GitHubConflictError, } from './common/errors.js';
 import { VERSION } from "./common/version.js";
 // If fetch doesn't exist in global scope, add it
 if (!globalThis.fetch) {
     globalThis.fetch = fetch;
 }
 // Default values from environment variables
-const DEFAULT_OWNER = process.env.GITHUB_DEFAULT_OWNER || '';
-const DEFAULT_REPO = process.env.GITHUB_DEFAULT_REPO || '';
-const server = new Server({
-    name: "github-mcp-server",
-    version: VERSION,
-}, {
-    capabilities: {
-        tools: {},
-    },
+const DEFAULT_OWNER = process.env.GITHUB_DEFAULT_OWNER;
+const AI_API_URL = process.env.AI_API_URL;
+const AI_API_TOKEN = process.env.AI_API_TOKEN;
+const server = new FastMCP({
+    name: "feedmob-github-mcp-server",
+    version: VERSION
 });
 function formatGitHubError(error) {
     let message = `GitHub API Error: ${error.message}`;
@@ -49,147 +41,164 @@ function formatGitHubError(error) {
     }
     return message;
 }
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                name: "create_issue",
-                description: "Create a new issue in a GitHub repository",
-                inputSchema: zodToJsonSchema(issues.CreateIssueSchema),
-            },
-            {
-                name: "list_issues",
-                description: "List issues in a GitHub repository with filtering options",
-                inputSchema: zodToJsonSchema(issues.ListIssuesOptionsSchema)
-            },
-            {
-                name: "update_issue",
-                description: "Update an existing issue in a GitHub repository",
-                inputSchema: zodToJsonSchema(issues.UpdateIssueOptionsSchema)
-            },
-            {
-                name: "search_issues",
-                description: "Search for issues and pull requests across GitHub repositories",
-                inputSchema: zodToJsonSchema(search.SearchIssuesSchema),
-            },
-            {
-                name: "get_issue",
-                description: "Get details of a specific issue in a GitHub repository.",
-                inputSchema: zodToJsonSchema(issues.GetIssueSchema)
+server.addResource({
+    uri: "issues/search_schema",
+    name: "search issues schema",
+    mimeType: "text/markdown",
+    async load() {
+        const response = await fetch(AI_API_URL + "/issues/scheam", {
+            method: 'GET',
+            headers: {
+                'Authorization': "Bearer " + AI_API_TOKEN,
             }
-        ],
-    };
+        });
+        return {
+            text: await response.text(),
+        };
+    },
 });
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        if (!request.params.arguments) {
-            throw new Error("Arguments are required");
-        }
-        switch (request.params.name) {
-            case "create_issue": {
-                const args = issues.CreateIssueSchema.parse(request.params.arguments);
-                // Use default values from environment variables if not provided
-                const owner = args.owner || DEFAULT_OWNER;
-                const repo = args.repo || DEFAULT_REPO;
-                const { ...options } = args;
-                if (!owner || !repo) {
-                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
-                }
-                try {
-                    console.error(`[DEBUG] Attempting to create issue in ${owner}/${repo}`);
-                    console.error(`[DEBUG] Issue options:`, JSON.stringify(options, null, 2));
-                    const issue = await issues.createIssue(owner, repo, options);
-                    console.error(`[DEBUG] Issue created successfully`);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
-                    };
-                }
-                catch (err) {
-                    // Type guard for Error objects
-                    const error = err instanceof Error ? err : new Error(String(err));
-                    console.error(`[ERROR] Failed to create issue:`, error);
-                    if (error instanceof GitHubResourceNotFoundError) {
-                        throw new Error(`Repository '${owner}/${repo}' not found. Please verify:\n` +
-                            `1. The repository exists\n` +
-                            `2. You have correct access permissions\n` +
-                            `3. The owner and repository names are spelled correctly`);
-                    }
-                    // Safely access error properties
-                    throw new Error(`Failed to create issue: ${error.message}${error.stack ? `\nStack: ${error.stack}` : ''}`);
-                }
+server.addTool({
+    name: "search_issues",
+    description: "Search GitHub Issues",
+    parameters: issues.FeedmobSearchOptions,
+    execute: async (args) => {
+        try {
+            let params = new URLSearchParams();
+            params.set('start_date', args.start_date);
+            params.set('end_date', args.end_date);
+            // 添加可选参数
+            if (args.status !== undefined) {
+                params.set('status', args.status);
             }
-            case "search_issues": {
-                const args = search.SearchIssuesSchema.parse(request.params.arguments);
-                const results = await search.searchIssues(args);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-                };
+            if (args.repo !== undefined) {
+                params.set('repo', args.repo);
             }
-            case "list_issues": {
-                const args = issues.ListIssuesOptionsSchema.parse(request.params.arguments);
-                // Use default values from environment variables if not provided
-                const owner = args.owner || DEFAULT_OWNER;
-                const repo = args.repo || DEFAULT_REPO;
-                const { ...options } = args;
-                if (!owner || !repo) {
-                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
-                }
-                const result = await issues.listIssues(owner, repo, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
+            if (args.users !== undefined) {
+                args.users.forEach(user => params.append('users[]', user));
             }
-            case "update_issue": {
-                const args = issues.UpdateIssueOptionsSchema.parse(request.params.arguments);
-                // Use default values from environment variables if not provided
-                const owner = args.owner || DEFAULT_OWNER;
-                const repo = args.repo || DEFAULT_REPO;
-                const { issue_number, ...options } = args;
-                if (!owner || !repo) {
-                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
-                }
-                const result = await issues.updateIssue(owner, repo, issue_number, options);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                };
+            if (args.team !== undefined) {
+                params.set('team', args.team);
             }
-            case "get_issue": {
-                const args = issues.GetIssueSchema.parse(request.params.arguments);
-                // Use default values from environment variables if not provided
-                const owner = args.owner || DEFAULT_OWNER;
-                const repo = args.repo || DEFAULT_REPO;
-                const { issue_number } = args;
-                if (!owner || !repo) {
-                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
+            const response = await fetch(`${AI_API_URL}/issues?${params}`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': "Bearer " + AI_API_TOKEN
                 }
-                const issue = await issues.getIssue(owner, repo, issue_number);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${request.params.name}`);
+            });
+            return {
+                content: [{ type: "text", text: await response.text() }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `API ERROR: ${error instanceof Error ? error.message : String(error)}` }],
+            };
         }
     }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            throw new Error(`Invalid input: ${JSON.stringify(error.errors)}`);
+});
+server.addTool({
+    name: "create_issue",
+    description: "Create a new issue in a GitHub repository",
+    parameters: issues.CreateIssueSchema,
+    execute: async (args) => {
+        const owner = args.owner || DEFAULT_OWNER;
+        const repo = args.repo;
+        const { ...options } = args;
+        if (!owner || !repo) {
+            throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER environment variables.");
         }
-        if (isGitHubError(error)) {
-            throw new Error(formatGitHubError(error));
+        try {
+            console.error(`[DEBUG] Attempting to create issue in ${owner}/${repo}`);
+            console.error(`[DEBUG] Issue options:`, JSON.stringify(options, null, 2));
+            const issue = await issues.createIssue(owner, repo, options);
+            console.error(`[DEBUG] Issue created successfully`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
+            };
         }
-        throw error;
-    }
+        catch (err) {
+            // Type guard for Error objects
+            const error = err instanceof Error ? err : new Error(String(err));
+            console.error(`[ERROR] Failed to create issue:`, error);
+            if (error instanceof GitHubResourceNotFoundError) {
+                throw new Error(`Repository '${owner}/${repo}' not found. Please verify:\n` +
+                    `1. The repository exists\n` +
+                    `2. You have correct access permissions\n` +
+                    `3. The owner and repository names are spelled correctly`);
+            }
+            // Safely access error properties
+            throw new Error(`Failed to create issue: ${error.message}${error.stack ? `\nStack: ${error.stack}` : ''}`);
+        }
+    },
 });
-async function runServer() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("GitHub MCP Server running on stdio");
-    if (DEFAULT_OWNER && DEFAULT_REPO) {
-        console.error(`Using default repository: ${DEFAULT_OWNER}/${DEFAULT_REPO}`);
-    }
-}
-runServer().catch((error) => {
-    console.error("Fatal error in main():", error);
-    process.exit(1);
+server.addTool({
+    name: "update_issue",
+    description: "Update an existing issue in a GitHub repository",
+    parameters: issues.UpdateIssueOptionsSchema,
+    execute: async (args) => {
+        const owner = args.owner || DEFAULT_OWNER;
+        const repo = args.repo;
+        const { issue_number, ...options } = args;
+        if (!owner || !repo) {
+            throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER environment variables.");
+        }
+        const result = await issues.updateIssue(owner, repo, issue_number, options);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    },
+});
+server.addTool({
+    name: "get_issue",
+    description: "Get details of a specific issue in a GitHub repository.",
+    parameters: issues.GetIssueSchema,
+    execute: async (args) => {
+        const owner = args.owner || DEFAULT_OWNER;
+        const repo = args.repo;
+        const { issue_number } = args;
+        if (!owner || !repo) {
+            throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER environment variables.");
+        }
+        const issue = await issues.getIssue(owner, repo, issue_number);
+        return {
+            content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
+        };
+    },
+});
+server.addTool({
+    name: "add_issue_comment",
+    description: "Add a comment to an existing issue",
+    parameters: issues.IssueCommentSchema,
+    execute: async (args) => {
+        const { owner, repo, issue_number, body } = args;
+        const result = await issues.addIssueComment(owner, repo, issue_number, body);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    },
+});
+server.addTool({
+    name: "sync_latest_issues",
+    description: "sync latest issues from Api",
+    execute: async () => {
+        try {
+            const response = await fetch(AI_API_URL + "/issues/sync_latest", {
+                method: 'GET',
+                headers: {
+                    'Authorization': "Bearer " + AI_API_TOKEN,
+                }
+            });
+            return {
+                content: [{ type: "text", text: await response.text() }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `API ERROR: ${error instanceof Error ? error.message : String(error)}` }],
+            };
+        }
+    },
+});
+server.start({
+    transportType: "stdio"
 });

package/dist/operations/issues.js

@@ -1,13 +1,23 @@
 import { z } from "zod";
 import { githubRequest, buildUrl } from "../common/utils.js";
+import { subDays, format } from 'date-fns';
+export const FeedmobSearchOptions = z.object({
+    scheam: z.string().describe("get from system resources issues/search_schema"),
+    start_date: z.string().default(format(subDays(new Date(), 6), 'yyyy-MM-dd')).describe("The creation start date of the issue"),
+    end_date: z.string().default(format(new Date(), 'yyyy-MM-dd')).describe("The creation end date of the issue"),
+    status: z.string().optional().describe("The status of the issue, e.g., 'open', 'closed'"),
+    repo: z.string().optional().describe("The repository name, e.g., 'feedmob', 'tracking_admin', If the user does not specify otherwise, this parameter can be omitted and all repos will be searched by default."),
+    users: z.array(z.string()).optional().optional(),
+    team: z.string().optional().describe("The team name, e.g., 'Star', 'Mighty'"),
+});
 export const GetIssueSchema = z.object({
     owner: z.string(),
-    repo: z.string(),
+    repo: z.string().describe("The repository name, e.g., 'feedmob', 'tracking_admin'"),
     issue_number: z.number(),
 });
 export const IssueCommentSchema = z.object({
     owner: z.string(),
-    repo: z.string(),
+    repo: z.string().describe("The repository name, e.g., 'feedmob', 'tracking_admin'"),
     issue_number: z.number(),
     body: z.string(),
 });
@@ -20,7 +30,7 @@ export const CreateIssueOptionsSchema = z.object({
 });
 export const CreateIssueSchema = z.object({
     owner: z.string().optional(),
-    repo: z.string().optional(),
+    repo: z.string().describe("The repository name, e.g., 'feedmob', 'tracking_admin'"),
     ...CreateIssueOptionsSchema.shape,
 });
 export const ListIssuesOptionsSchema = z.object({
@@ -36,7 +46,7 @@ export const ListIssuesOptionsSchema = z.object({
 });
 export const UpdateIssueOptionsSchema = z.object({
     owner: z.string(),
-    repo: z.string(),
+    repo: z.string().describe("The repository name, e.g., 'feedmob', 'tracking_admin'"),
     issue_number: z.number(),
     title: z.string().optional(),
     body: z.string().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feedmob/github-issues",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "MCP server for using the GitHub API",
   "license": "MIT",
   "author": "FeedMob",
@@ -19,6 +19,8 @@
     "watch": "tsc --watch"
   },
   "dependencies": {
+    "date-fns": "^4.1.0",
+    "fastmcp": "2.1.0",
     "@modelcontextprotocol/sdk": "1.0.1",
     "@types/node": "^22",
     "@types/node-fetch": "^2.6.12",