docs: add comprehensive Cursor IDE rules for MCP DevTools development

This commit introduces a set of detailed Cursor IDE rules to standardize development practices:
- Create rules for AI-assisted development guidelines
- Define core libraries usage standards
- Establish MCP server and tool implementation patterns
- Add testing and TypeScript coding standards
- Provide guidelines for package creation and documentation
- Enhance repository structure documentation

Author: prokopsimek

.cursor/rules/ai-assisted-development.mdc

@@ -0,0 +1,76 @@
+---
+description: AI-Assisted Development Guidelines
+globs: **/*
+alwaysApply: false
+---
+
+# AI-Assisted Development Guidelines
+
+Follow these guidelines when using Cursor IDE with AI assistance for MCP DevTools development:
+
+@url https://docs.cursor.com/
+@file .cursor/rules/repository-structure.md
+
+## Effective AI Prompts
+
+1. **Be Specific**
+
+   - Include file paths and line numbers when referencing code
+   - Specify the expected behavior, not just the task
+   - Include relevant context (e.g., "This is part of the Jira MCP integration")
+
+2. **Chunk Complex Tasks**
+
+   - Break down complex tasks into smaller steps
+   - Ask for one implementation at a time
+   - Verify each step before proceeding to the next
+
+3. **Request Explanations**
+   - Ask AI to explain its reasoning
+   - Request documentation alongside implementation
+   - Ask for alternative approaches when appropriate
+
+## Code Review Assistance
+
+1. **Request Focused Reviews**
+
+   - Ask AI to review specific aspects (security, performance, etc.)
+   - Provide the full context of the code being reviewed
+   - Ask for specific improvements rather than general feedback
+
+2. **Validation Assistance**
+   - Ask AI to help write tests for your code
+   - Request validation of edge cases
+   - Use AI to check for potential bugs or edge cases
+
+## Documentation Assistance
+
+1. **Generate Documentation**
+
+   - Ask AI to create or update README sections
+   - Request JSDoc comments for functions
+   - Use AI to help document complex algorithms
+
+2. **Consistency**
+   - Ask AI to ensure documentation follows the project standards
+   - Request help maintaining consistent terminology
+   - Use AI to check for documentation gaps
+
+## Best Practices
+
+1. **Always Review AI-Generated Code**
+
+   - Check for correctness and appropriateness
+   - Verify complex algorithms
+   - Ensure it meets project standards
+
+2. **Iterative Refinement**
+
+   - Start with a basic implementation
+   - Refine with more specific requirements
+   - Use AI to help optimize the code
+
+3. **Enhance, Don't Replace**
+   - Use AI as a collaborator, not a replacement
+   - Maintain ownership of the code
+   - Understand the code AI generates

.cursor/rules/core-libraries-usage.mdc

@@ -0,0 +1,95 @@
+---
+description: Core Libraries Usage Guidelines
+globs: packages/*/src/**/*.ts
+alwaysApply: true
+---
+
+# Core Libraries Usage Guidelines
+
+When developing MCP DevTools packages, prefer using shared core libraries over custom implementations to ensure consistency and maintainability.
+
+@file packages/jira/src/index.ts
+@file .cursor/rules/mcp-server-implementation.md
+
+## Required Core Libraries
+
+| Library       | Package                           | Purpose                   | Import Statement                                                         |
+| ------------- | --------------------------------- | ------------------------- | ------------------------------------------------------------------------ |
+| MCP Server    | `@modelcontextprotocol/server`    | Core server functionality | `import { createMcpServer } from '@modelcontextprotocol/server';`        |
+| MCP Inspector | `@modelcontextprotocol/inspector` | Debugging tools           | `import { inspector } from '@modelcontextprotocol/inspector';`           |
+| MCP Types     | `@modelcontextprotocol/types`     | Shared type definitions   | `import { McpRequest, McpResponse } from '@modelcontextprotocol/types';` |
+
+## Common Utilities
+
+The MCP DevTools core utilities should be used instead of reimplementing common functionality:
+
+```typescript
+// PREFERRED: Import from core utilities
+import { validateEnvVars, formatErrorResponse } from "@mcp-devtools/core/utils";
+
+// AVOID: Custom implementation of utilities
+const validateEnvVars = (required) => {
+  /* ... */
+}; // Don't do this
+```
+
+## Configuration Management
+
+Use the shared configuration management from core:
+
+```typescript
+import { loadConfig } from "@mcp-devtools/core/config";
+
+// Load configuration with standard validation
+const config = loadConfig({
+  requiredVars: ["API_KEY", "API_URL"],
+  optionalVars: {
+    TIMEOUT: "30000",
+    DEBUG: "false",
+  },
+});
+```
+
+## HTTP Client
+
+Use the shared HTTP client with standard error handling:
+
+```typescript
+import { httpClient } from "@mcp-devtools/core/http";
+
+// Make HTTP requests with standard error handling
+const response = await httpClient.get("https://api.example.com/data", {
+  headers: { Authorization: `Bearer ${config.API_KEY}` },
+});
+```
+
+## Logging
+
+Use the standardized logging system:
+
+```typescript
+import { logger } from "@mcp-devtools/core/logger";
+
+// Log with standard levels and formatting
+logger.info("Operation successful", { operationId: "123" });
+logger.error("API call failed", { error, statusCode: 500 });
+```
+
+## Authentication Helpers
+
+Use shared authentication utilities:
+
+```typescript
+import { createAuthHeaders, validateToken } from "@mcp-devtools/core/auth";
+
+// Create standard auth headers
+const headers = createAuthHeaders(config.API_KEY, config.API_SECRET);
+```
+
+## Guidelines
+
+1. **Always check core libraries first** before implementing new functionality
+2. **Keep dependencies updated** to ensure security and compatibility
+3. **Contribute improvements** back to core libraries instead of creating package-specific versions
+4. **Document usage** of core libraries in your package's README
+5. **Follow versioning guidelines** when updating core library dependencies

.cursor/rules/mcp-server-implementation.mdc

@@ -0,0 +1,93 @@
+---
+description: MCP Server Implementation Guidelines
+globs: packages/*/src/index.ts
+alwaysApply: true
+---
+
+# MCP Server Implementation Guidelines
+
+When implementing a new MCP server or updating an existing one, follow these guidelines:
+
+@file packages/jira/src/index.ts
+@file .cursor/rules/core-libraries-usage.md
+@file .cursor/rules/typescript-style.md
+
+## Server Setup
+
+```typescript
+import { createMcpServer } from "@modelcontextprotocol/server";
+import { registerTool1 } from "./tools/tool1";
+import { registerTool2 } from "./tools/tool2";
+// Import more tools as needed
+
+// Create configuration with proper error handling
+const getConfig = (): Config => {
+  const required = ["REQUIRED_ENV_VAR1", "REQUIRED_ENV_VAR2"];
+  for (const env of required) {
+    if (!process.env[env]) {
+      console.error(`Missing required environment variable: ${env}`);
+      process.exit(1);
+    }
+  }
+
+  return {
+    var1: process.env.REQUIRED_ENV_VAR1,
+    var2: process.env.REQUIRED_ENV_VAR2,
+    optionalVar: process.env.OPTIONAL_ENV_VAR || "default",
+  };
+};
+
+// Initialize server
+const initServer = async () => {
+  try {
+    const config = getConfig();
+    const server = createMcpServer();
+
+    // Register all tools
+    registerTool1(server);
+    registerTool2(server);
+    // Register more tools
+
+    // Start the server
+    server.start();
+    console.log("MCP server started successfully");
+  } catch (error) {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  }
+};
+
+// Start the server
+initServer();
+```
+
+## Guidelines
+
+1. **Environment Variables**
+
+   - Validate all required environment variables at startup
+   - Provide sensible defaults for optional variables
+   - Document all environment variables in README
+
+2. **Error Handling**
+
+   - Implement proper error handling for server initialization
+   - Log meaningful error messages
+   - Exit with non-zero code on critical errors
+
+3. **Tool Registration**
+
+   - Register each tool from its own module
+   - Keep registration code organized and maintainable
+   - Use consistent patterns across all tools
+
+4. **Logging**
+
+   - Log server start/stop events
+   - Include appropriate context in logs
+   - Avoid logging sensitive information
+
+5. **Server Configuration**
+   - Centralize configuration in one place
+   - Validate configuration at startup
+   - Use typed configuration objects

.cursor/rules/mcp-tool-implementation.mdc

@@ -0,0 +1,59 @@
+---
+description: MCP Tool Implementation Guidelines
+globs: packages/*/src/tools/*.ts
+alwaysApply: true
+---
+
+# MCP Tool Implementation Guidelines
+
+When implementing a new MCP tool, follow these patterns:
+
+@file packages/jira/src/tools/getTicket.ts
+@file .cursor/rules/typescript-style.mdc
+
+## Tool Registration
+
+```typescript
+export const registerToolName = (server: McpServer): void => {
+  const toolParams = {
+    // Define parameters according to JSON schema
+  };
+
+  // For tools with aliases, use an array of tool names
+  const toolNames = ["primary_tool_name", "alias_1", "alias_2"];
+
+  // Register all tool names with the same handler
+  for (const tool of toolNames) {
+    server.tool(tool, toolParams, async (params) => {
+      try {
+        // Implementation
+        return {
+          message: "Success message",
+        };
+      } catch (error) {
+        return {
+          error: `Error message: ${error.message}`,
+        };
+      }
+    });
+  }
+};
+```
+
+## Parameter Validation
+
+- Always validate required parameters early in the function
+- Use TypeScript types/interfaces for parameter typing
+- Document parameters with clear descriptions
+
+## Error Handling
+
+- Use try/catch blocks for all API calls
+- Return meaningful error messages
+- Log errors with appropriate context
+
+## Documentation
+
+- Update the README.md with your new tool
+- Add the tool to the Tool Reference table with all parameters
+- Include any aliases in the documentation