Modular Tool Framework (Jira & Todo)

🚀 MCP Server

A TypeScript-based implementation of the Model Context Protocol (MCP) server, offering an integrated tool for multiple services such as JIRA and to-do management.

🚀 Quick Start

This MCP server is a TypeScript-based solution that integrates multiple tools, providing a unified platform for various services.

✨ Features

• Multi-tool Integration: The modular architecture supports the integration of multiple tools.
• Type Safety: Comprehensive TypeScript support combined with Zod schema validation.
• ESM Support: Implemented with modern ES modules.
• Scalability: Easily add new tools and integrations.

📦 Current Tools

JIRA Integration

• Create issues using custom fields.
• Automatically format responses.
• Validate the schema when creating issues.

To-do Management

• Create to-dos with priorities and deadlines.
• Flexible schema supports optional fields.
• Format response messages.

🛠 Project Structure

src/
├── config/           # Tool configurations
│   ├── jira-tool.config.ts
│   └── todo-tool.config.ts
├── constant/         # Constant definitions
│   └── tool-name.ts
├── schema/          # Zod schema validation
│   ├── jira.ts
│   └── todo.ts
├── server/          # Server management
│   └── mcp-server-tool-manager.ts
├── tools/           # Tool implementations
│   ├── jira/
│   │   └── create-issue.ts
│   └── todo/
│       └── create-todo.ts
└── index.ts         # Main entry point

💻 Usage Examples

Adding a New Tool

1. Define the tool constant in constant/tool-name.ts.
2. Create the schema in the schema/ directory.
3. Implement the tool handler in the tools/ directory.
4. Add the configuration in the config/ directory.
5. Register the tool in index.ts.

// 1. Add a constant
export const NEW_TOOL = {
  ACTION: "action_name"
} as const;

// 2. Create a schema
export const newToolSchema = z.object({
  // ... Schema definition
});

// 3. Implement the handler
export const handleAction = async (
  args: z.infer<typeof newToolSchema>,
  extra: RequestHandlerExtra
): Promise<CallToolResult> => {
  // ... Implementation logic
};

// 4. Add the configuration
export const newToolConfig = {
  name: "NEW_TOOL",
  version: "1.0.0",
  tools: [
    {
      name: NEW_TOOL.ACTION,
      schema: newToolSchema,
      handler: handleAction,
    },
  ],
};

🔧 Technical Details

Development Workflow

1. Create a feature branch.
2. Implement changes.
3. Run tests (when implemented).
4. Build the project.
5. Submit a PR.

Notes

• Use ES modules for better modularity.
• Implement the Model Context Protocol for standardized communication.
• Follow TypeScript best practices.
• Use Zod schema validation to ensure type safety.

Roadmap

• [ ] Add more JIRA operations.
• [ ] Implement to-do persistence.
• [ ] Add authentication.
• [ ] Add a testing framework.
• [ ] Add more integrations (GitHub, Slack, etc.).

📄 License

MIT