mcp-curl: Instructions file for GitHub Copilot

Copilot Instructions

This repository is a JavaScript/TypeScript library/application. When generating or suggesting code, reinforce and follow the principles and objectives outlined below:

Core Development Guidance

1. Efficiency and Performance

• Prefer fast, efficient code with minimal runtime overhead.
• Avoid unnecessary iterations, blocking operations, and patterns that cause memory leaks.
• Use appropriate data structures (Map/Set over Object/Array when beneficial for lookups).
• Prefer async/await patterns; avoid callback hell and unnecessary synchronous operations.
• Be mindful of bundle size—prefer tree-shakeable imports and lightweight dependencies.
• Use memoization or caching for expensive computations when appropriate.
• Avoid unnecessary re-renders in UI frameworks (React, Vue, etc.).

2. JavaScript/TypeScript Best Practices

• Use modern ES6+ syntax (const/let over var, arrow functions, destructuring, template literals).
• Provide TypeScript types or JSDoc annotations for all public APIs and complex functions.
• Prefer named exports over default exports for better tree-shaking and refactoring.
• Use dependency injection or module patterns; avoid hard-coded dependencies.
• Validate inputs at module boundaries using schema validation (Zod, Yup, Joi) for complex cases.
• Follow consistent module organization (barrel files, feature-based folders).
• Prefer pure functions and immutable data patterns where practical.
• Use Promises or async/await consistently—never mix callbacks and promises.
• Handle all Promise rejections and async errors appropriately.

3. SRP & DRY Principles

• Avoid code duplication (DRY). Extract repeated logic into reusable functions or modules.
• Follow the Single Responsibility Principle (SRP):
  • Entry points/handlers should be thin, delegating business logic to services or utilities.
  • Modules/classes should handle one logical concern (not mixing unrelated tasks).
• Prefer composition over inheritance for code reuse.
• Extract complex conditionals into well-named functions or constants.