my-ai-chat-framework 2.0.0 → 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [3.0.0] - 2026-08-?
+
+### Added
+- **公开管道 API**：`chat.pipe({ name, phase?, run(ctx) })` / `chat.unpipe(name)` / `chat.pipelineStages`
+  - phase `beforeSend`（默认）：内部 beforeRequest 之后、构建请求体之前
+  - phase `afterSend`：发送完成、结果落位之后（可改 ctx.result）
+  - 不注册任何车间 = 行为与 2.8.x 完全一致
+- **协议固化**：`assertAdapter` 校验 buildRequest/send/stream/parseResponse，缺方法抛 ConfigurationError 并列出方法名；JSDoc @typedef ChatAdapter / PipelineContext / PipeStage
+- **插件车间化**：tool-calling 经 afterSend 车间、model-registry 经 beforeSend 车间，不再占用 `_processResponse` 单座槽位
+- 新增测试 `tests/pipeline.test.js`（8 例：pipe 顺序/冲突/unpipe/改ctx/SSE 冒烟/工具循环端到端）
+
+### Changed
+- `ChatService._request` 固定线拆为内部管道：prepareInput → beforeSend → autoContinue → buildRequest → send（行为等价）
+- `_hooks` beforeRequest 保留为兼容桥；`_processResponse` 保留为旧通道（新代码请用 afterSend 车间）
+- 版本号 2.8.0 → 3.0.0（新增公共 API 面）
+
+### Known delta（流式 tool-calling 时序）
+- 流式工具调用时，初始回复的 `message` 事件在工具循环前发出（旧版循环后发）。非流式时序与旧版一致。
+
+## [2.8.0] - 2026-08-08
+
+### Added
+- **配置归属系统**：配置按层归属（运输/请求/会话/插件），谁消费谁声明
+- **工厂函数**：`createOpenAIAdapter(opts)` / `createToolCallingPlugin(opts)` / `createModelRegistryPlugin(opts)`——每个实例自持状态，规避模块级单例互踩陷阱
+- **请求级参数覆盖**：`chat.send(input, params)` / `chat.stream(input, params, onProgress, onDone)` / `sendExisting(params)` / `sendExistingStream(params, ...)`，合并链 = 适配器默认 ← 会话配置 ← 本次覆盖（近者优先）
+- **capabilities 按生效 model 解析**：model-registry 在 beforeRequest 钩子里按"本次请求的 model"（含请求级覆盖）查表
+- `chat.use(plugin, options)`：options 透传 `plugin.install(chat, options)`
+- `new ChatService({ adapter })`：构造时直接注入适配器
+- 工具定义移入插件实例（不再写 `chat.config.tools`），工具超时改走 `createToolCallingPlugin({ timeout })`
+
+### Changed
+- `updateConfig` 收窄为会话层字段（model/temperature/maxTokens/modelParams/system/retry/ephemeralContinue），非白名单或非法值抛 `ConfigurationError`（修复绕过校验问题）
+- openaiAdapter 的 transport（apiKey/baseUrl/headers）从实例自持，单例 `openaiAdapter` 保留为平铺兼容路径
+- `buildRequest(messages, config, systemPrompts)` 的 config 现为合并后的请求参数
+
+### Fixed
+- TODO.md 高危 #1：插件共享可变状态——工厂化后实例隔离（单例保留为兼容路径）
+- TODO.md 高危 #3：updateConfig 绕过校验——现在白名单 + 校验
+
+## [2.7.0] - 2026-05-25
+
+### Added
+- **Ephemeral 临时消息**：_ephemeral: true 标记，仅底部连续时参与请求，其余自动过滤
+- **续写转正**：continueLast / continueLastStream 续写 ephemeral 消息后自动转正（delete _ephemeral）
+- **EventEmitter.emitAsync**：异步触发事件，支持 beforeRequest 等钩子
+- **beforeRequest 钩子**：chat._hooks.on('beforeRequest', ...) 在 buildRequest 前修改 messages
+- **_processResponse 钩子**：tool-calling 改为注册此钩子，不再覆盖 send/stream
+
+### Changed
+- MessageFormatter 过滤 ephemeral：识别底部连续段，中间 ephemeral 自动跳过
+- ChatService._request 拆为 4 个私有方法（_addUserMessage / _withRetry / _stream / _handleResult）
+- 	ool-calling.js 改为注册 _processResponse，不再替换 send/stream
+- dapter.stream 不再接收/操作 streamEntry，_complete 由 ChatService 管理
+- openaiAdapter.stream 约减 20 行（删除所有 entry 相关代码）
+
+### Fixed
+- retry 循环重复 push 占位消息（已修复：提到循环外）
+- continueLastStream 被续写消息丢失（已修复：独立占位，ChatService 管理）
+- prefix 续写空 content 被过滤（已修复：MessageFormatter 保留 prefix）
+
+## [2.6.0] - 2026-05-23

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 My Name
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2024 My Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/README.md

@@ -1,19 +1,66 @@
 
- **⚠️ Note**: This project is created for **learning purposes** and is **AI‑generated**. It is not intended for production use. No backward compatibility is guaranteed. Use at your own risk.
- 
 # 🤖 My AI Chat Framework
 
 A lightweight, modular AI chat framework with plugin system, unified message format, and tool calling support.
 
+> **⚠️ Note**: This project is created for **learning purposes** and is **AI‑generated**. It is not intended for production use. No backward compatibility is guaranteed. Use at your own risk.
+
 ## ✨ Features
 
-- **Lightweight Core** – Only ~300 lines, easy to understand and extend.
-- **Plugin System** – Add features like tool calling, reasoning, or custom adapters without touching the core.
+- **Lightweight Core** – ~300 lines, easy to understand and extend.
+- **Plugin System** – Add features (tool calling, reasoning, custom adapters) without touching the core.
 - **Unified Message Format** – Consistent data structure across all components.
-- **Multi‑Environment** – Builds ES module, UMD, and CommonJS formats for browser and Node.js.
+- **Multi‑Environment** – Builds ES module, UMD, and CommonJS for browser & Node.js.
 - **No External Dependencies** – Uses native `fetch` (Node 18+ & modern browsers).
 - **Tool Calling** – Built‑in plugin to handle function calls from AI models.
 - **Streaming** – Full support for real‑time responses.
+- **Flexible Configuration** – Supports both flat and nested `modelParams` structure.
+- **Event‑Driven** – Built‑in EventEmitter for `message`, `sending`, `error`, `stream-progress` events.
+- **Pipeline Stages (v3.0)** – `chat.pipe()` to hook custom logic at `beforeSend` / `afterSend` without touching the core.
+- **Custom Error Classes** – `APIError`, `NetworkError`, `ConfigurationError`, `ParsingError` for fine‑grained error handling.
+
+---
+
+## 🧱 Architecture
+
+```
+src/
+├── index.js                  # Public entry point (re-exports)
+├── core/
+│   ├── ChatService.js        # Main service: config, pipeline, send/stream, plugin hosting
+│   ├── Pipeline.js           # Sequential pipeline (v3.0: ctx flows through stages)
+│   ├── MessageStore.js       # In-memory message list with CRUD helpers
+│   ├── SystemPromptStore.js  # Toggleable system prompts
+│   ├── EventEmitter.js       # Minimal pub/sub (on/off/emit)
+│   └── Errors.js             # Custom error classes
+├── adapters/
+│   └── openai.js             # OpenAI‑compatible API adapter (protocol via assertAdapter)
+├── plugins/
+│   ├── tool-calling.js       # Tool calling plugin (afterSend stage, auto‑detect & loop)
+│   └── model-registry.js     # Model capability table (beforeSend stage)
+└── utils/
+    ├── MessageFormatter.js   # Message format conversion (registrable)
+    ├── typeCheck.js          # Type checking helpers
+    └── url.js                # URL joining utility
+tests/                        # node:test suites (core / pipeline / integration)
+```
+
+**Data flow**:
+
+```
+User calls chat.send(input)
+  → ChatService._request() → ctx flows through stages:
+    → prepareInput (add user msg, merge config, emit 'sending')
+    → beforeSend (internal hook + user beforeSend stages)
+    → autoContinue / buildRequest (→ request body)
+    → send (adapter.send / stream + retry + placeholder)
+    → afterSend (user stages + tool-calling loop)
+    → returns result, emitting 'message' along the way
+```
+
+With `toolCallingPlugin`, the flow loops: response → detect tool_calls → execute tools → add tool results → sendExisting → repeat (max 5 iterations).
+
+---
 
 ## 📦 Installation
 
@@ -21,72 +68,303 @@ A lightweight, modular AI chat framework with plugin system, unified message for
 npm install my-ai-chat-framework
 ```
 
+---
+
 ## 🚀 Quick Start
 
+### Basic Usage (Flat Configuration)
+
 ```javascript
 import { ChatService, openaiAdapter, toolCallingPlugin } from 'my-ai-chat-framework';
 
 const chat = new ChatService({
   apiKey: 'your-api-key',
+  baseUrl: 'https://api.deepseek.com',    // optional, defaults to OpenAI
   model: 'deepseek-chat',
-  apiUrl: 'https://api.deepseek.com/v1/chat/completions'
+  temperature: 0.7,
+  maxTokens: 2000
 });
 
 chat.use(openaiAdapter);
 chat.use(toolCallingPlugin);
 
-chat.registerTool('greet', 'Say hello', async (args) => {
-  return `Hello, ${args.name}!`;
+chat.on('message', msg => console.log(msg.content));
+await chat.send('Hello!');
+```
+
+### Factory Mode (Owned Configuration, Recommended)
+
+```javascript
+import { ChatService, createOpenAIAdapter, createToolCallingPlugin } from 'my-ai-chat-framework';
+
+// transport + request defaults belong to the adapter
+const adapter = createOpenAIAdapter({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://api.deepseek.com',
+  modelParams: { temperature: 0.8, maxTokens: 2000 }
 });
 
-chat.on('message', msg => console.log(msg.content));
+const chat = new ChatService({
+  adapter,                    // injected at construction (same as chat.use(adapter))
+  model: 'deepseek-chat',
+  system: 'You are a helpful assistant'
+});
+
+chat.use(createToolCallingPlugin({ timeout: 30000 }));  // plugin options
+
+// per-request override (this request only)
+await chat.send('Hello', { temperature: 0.2 });
+```
+
+> ⚠️ The default exports `openaiAdapter` / `toolCallingPlugin` / `modelRegistryPlugin` are module-level singletons — installing one on multiple `ChatService` instances will clobber shared state. Use the factories (`createXxx`) for multiple instances.
+
+### Using `modelParams` (Recommended for Many Parameters)
+
+```javascript
+const chat = new ChatService({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://api.deepseek.com',
+  model: 'deepseek-chat',               // still at top level for convenience
+  modelParams: {                         // optional parameters grouped
+    temperature: 0.8,
+    maxTokens: 1500,
+    reasoningEffort: 'medium'           // for deepseek-reasoner
+  }
+});
+```
 
-await chat.send('Please greet Alice.');
+### Registering a Tool
+
+```javascript
+chat.registerTool('get_weather', 'Get current weather for a city',
+  async (args) => {
+    // args = { city: 'Beijing' }
+    return `Weather in ${args.city}: 22°C, sunny`;
+  },
+  {  // parameter schema (optional but recommended)
+    city: { type: 'string', description: 'City name', required: true }
+  }
+);
+
+await chat.send('What\'s the weather in Beijing?');
+// → AI calls get_weather, framework executes it, AI responds with weather info
 ```
 
+---
+
 ## 🔌 Plugins & Adapters
 
-- **openaiAdapter** – Converts internal messages to OpenAI-compatible format.
-- **toolCallingPlugin** – Detects `tool_calls` in responses, executes tools, and continues the conversation.
+### openaiAdapter
+
+Converts internal messages to OpenAI‑compatible format. Supports:
+- `apiUrl` – full URL (highest priority)
+- `baseUrl` + `path` – base domain + API path
+- Defaults to `https://api.openai.com/v1/chat/completions`
+
+| Config field | Type | Default | Description |
+|-------------|------|---------|-------------|
+| `apiKey` | string | **required** | Bearer token for Authorization header |
+| `apiUrl` | string | – | Full request URL (overrides baseUrl+path) |
+| `baseUrl` | string | `https://api.openai.com` | API base domain |
+| `path` | string | `/v1/chat/completions` | API endpoint path |
+
+### toolCallingPlugin
+
+Detects `tool_calls` in assistant responses, executes registered tools, feeds results back, and continues the conversation (up to `maxIterations` = 5).
+
+- `chat.registerTool(name, description, executor, parameters?)` – register a tool
+- Automatically injects `tool` role messages into the conversation
+- Recovers from tool execution errors gracefully (logs error, returns error message to model)
+
+---
+
+## 🔧 Extending with Pipeline (v3.0)
+
+```javascript
+// Inject a role card before every request
+chat.pipe({ name: 'role-card', phase: 'beforeSend', async run(ctx) {
+  ctx.messages.add({ role: 'system', content: 'You are a tsundere CEO.' });
+}});
+
+// Post-process the reply
+chat.pipe({ name: 'stamp', phase: 'afterSend', run(ctx) {
+  if (ctx.result?.content) ctx.result.content += ' — ' + Date.now();
+}});
+
+chat.unpipe('role-card');   // remove
+console.log(chat.pipelineStages);  // inspect stage order
+```
+
+See `docs/DEVELOPER.md` \u201cWrite a Stage\u201d for the full guide.
+
+## 📡 Events (EventEmitter)
+
+`ChatService` extends `EventEmitter`. Subscribe with `chat.on(event, handler)`:
+
+| Event | Payload | When |
+|-------|---------|------|
+| `sending` | `{ addUser, userInput, timestamp }` | Before each request |
+| `message` | `{ role, content, ... }` | Full assistant message received |
+| `stream-progress` | chunk object | Each streaming chunk arrives |
+| `error` | `{ error, timestamp }` | Any error during request |
+
+```javascript
+chat.on('sending', ({ userInput }) => console.log('Sending:', userInput));
+chat.on('message', msg => console.log('Got:', msg.content));
+chat.on('error', ({ error }) => console.error('Error:', error.message));
+
+// on() returns an unsubscribe function
+const unsubscribe = chat.on('message', handler);
+unsubscribe(); // stop listening
+```
+
+---
+
+## 🧩 ChatService API
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `chat.send(userInput)` | `Promise<Message>` | Send a message, get reply (non‑streaming) |
+| `chat.stream(userInput, onProgress, onDone)` | `Promise<Message>` | Send a message, get streaming reply |
+| `chat.sendExisting()` | `Promise<Message>` | Re‑send current messages without adding user input |
+| `chat.sendExistingStream(onProgress, onDone)` | `Promise<Message>` | Same as above, streaming |
+| `chat.use(plugin)` | `this` | Install a plugin/adapter |
+| `chat.setAdapter(adapter)` | `void` | Manually set the adapter |
+| `chat.on(event, handler)` | `unsubscribe function` | Subscribe to events |
+| `chat.registerTool(name, desc, fn, params?)` | `this` | Register a tool (requires toolCallingPlugin) |
+| `chat.messages` | `MessageStore` | Access the message store directly |
+
+---
+
+## 🗄️ MessageStore API
+
+| Method | Description |
+|--------|-------------|
+| `add(message)` | Add a raw message object |
+| `addUser(content, meta?)` | Add a user message |
+| `addAssistant(content, meta?)` | Add an assistant message |
+| `addSystem(content, meta?)` | Add a system message |
+| `addTool(content, toolCallId, meta?)` | Add a tool result message |
+| `addOnceAssistant(content, options?)` | Add a one-shot assistant guide message (defaults to `_ephemeral: true` + `prefix: true`; options: `{ reasoningContent, prefix }`) |
+| `getAll()` | Return a shallow copy of all messages |
+| `getLast()` | Return the last message (or null) |
+| `clear()` | Remove all messages |
+| `undoToLastAssistant()` | Remove messages after the last assistant message |
+| `undoToPreviousUser(id)` | Remove messages from the message with `id` (inclusive) back to, but excluding, the previous user message — useful before resending |
+
+**Message format**:
+
+```javascript
+{
+  id: string,           // auto‑generated if not provided
+  role: 'user' | 'assistant' | 'system' | 'tool',
+  content: string,
+  toolCalls?: Array,    // assistant messages with tool calls
+  toolCallId?: string,  // tool messages
+  reasoningContent?: string,  // deepseek-reasoner
+  timestamp?: number,
+  metadata?: any
+}
+```
+
+---
+
+## ❌ Error Handling
 
-You can easily create your own adapter for other APIs (Anthropic, Cohere, etc.) or plugins for logging, caching, etc.
+The framework throws typed errors for different failure modes:
 
-## 📚 API
+| Error Class | `.name` | When |
+|------------|---------|------|
+| `APIError` | `'APIError'` | Non‑2xx HTTP responses (401, 429, 500, etc.) |
+| `NetworkError` | `'NetworkError'` | `fetch` failures, connection timeouts |
+| `ConfigurationError` | `'ConfigurationError'` | Missing required config |
+| `ParsingError` | `'ParsingError'` | Malformed API response |
 
-### ChatService
+```javascript
+import { APIError, NetworkError, ConfigurationError, ParsingError } from 'my-ai-chat-framework';
+
+try {
+  await chat.send('Hello');
+} catch (error) {
+  if (error instanceof APIError) {
+    console.error(`API ${error.statusCode}: ${error.message}`);
+  } else if (error instanceof NetworkError) {
+    console.error('Network issue:', error.message);
+  }
+}
+```
+
+---
+
+## 📚 Configuration Reference
+
+`new ChatService(config)` accepts:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | string | **required** | Your API key |
+| `baseUrl` | string | `'https://api.openai.com'` | API base URL (used with `path`) |
+| `path` | string | `'/v1/chat/completions'` | API path (used with `baseUrl`) |
+| `apiUrl` | string | – | Full API URL (overrides `baseUrl`+`path`) |
+| `model` | string | **required** | Model name (e.g., `deepseek-chat`) |
+| `modelParams` | object | `{}` | Grouped model parameters (see below) |
+| `temperature` | number | `0.7` | Sampling temperature (0–2) |
+| `maxTokens` | number | `2000` | Max tokens to generate |
+| `reasoningEffort` | string | – | For `deepseek-reasoner`: `'low'`, `'medium'`, `'high'` |
+
+> Both flat and `modelParams` styles work. `modelParams` takes precedence over top‑level values.
+
+### modelParams
+
+`modelParams` groups all model-related parameters. Supported fields:
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `model` | string | – | Model name (overrides top-level `model`) |
+| `temperature` | number | `0.7` | Sampling temperature (0–2) |
+| `maxTokens` | number | `2000` | Max tokens to generate |
+| `reasoningEffort` | string | – | For `deepseek-reasoner`: `'low'`, `'medium'`, `'high'` |
+| `topP` | number | – | Nucleus sampling (0–1) |
+| `frequencyPenalty` | number | – | Penalize frequent tokens (-2.0–2.0) |
+| `presencePenalty` | number | – | Penalize repeated tokens (-2.0–2.0) |
+| `stop` | string \| string[] | – | Stop sequences |
+| `responseFormat` | object | – | e.g., `{ type: 'json_object' }` |
+| `seed` | number | – | For reproducible results |
+
+**Naming convention**: CamelCase fields (`maxTokens`, `topP`) are managed by the adapter (converted to API format). Any unknown field is passed through as‑is—use the provider's native naming (e.g., `snake_case` for OpenAI).
 
-```typescript
-new ChatService(config: {
-  apiKey: string;
-  model?: string;
-  apiUrl?: string;
-  temperature?: number;
-  maxTokens?: number;
-})
+```javascript
+const chat = new ChatService({
+  apiKey: 'your-api-key',
+  baseUrl: 'https://api.deepseek.com',
+  model: 'deepseek-chat',
+  modelParams: {
+    temperature: 0.8,
+    maxTokens: 1500,
+    topP: 0.9,
+    frequencyPenalty: 0.5,
+    // unknown fields pass through directly (use API's native names):
+    logprobs: true,
+    top_logprobs: 5
+  }
+});
 ```
 
-- `use(plugin)` – Load a plugin.
-- `send(message)` – Send a message and wait for the complete response.
-- `stream(message, onProgress, onDone)` – Stream the response.
-- `registerTool(name, description, executor)` – Register a tool (only available after loading `toolCallingPlugin`).
+---
 
-### MessageStore
+## 🧪 Testing
 
-- `add(message)` – Add a message (unified format).
-- `addUser(content, metadata)` – Convenience method.
-- `addAssistant(content, metadata)`
-- `addSystem(content, metadata)`
-- `addTool(content, toolCallId, metadata)`
-- `getAll()` – Get all messages.
-- `undoToLastAssistant()` – Rollback to the last assistant message.
+```bash
+# 1. Create a .env file with your API key
+echo "DEEPSEEK_API_KEY=sk-xxxxx" > .env
 
-### EventEmitter
+# 2. Run the test
+npm test
+```
 
-- `on(event, handler)` – Subscribe to events.
-- `off(event, handler)` – Unsubscribe.
-- `emit(event, data)` – Emit an event.
+Unit tests: `npm test` (`tests/core.test.js` + `tests/pipeline.test.js`, no API key needed). Integration test: `npm run test:integration` (`tests/integration.test.js`, requires `DEEPSEEK_API_KEY` in `.env`).
 
-Events: `sending`, `message`, `stream-progress`, `error`, etc.
+---
 
 ## 🛠️ Development
 
@@ -94,14 +372,20 @@ Events: `sending`, `message`, `stream-progress`, `error`, etc.
 git clone https://github.com/your-username/my-ai-chat-framework.git
 cd my-ai-chat-framework
 npm install
-npm run build   # build the library
-npm test        # run the test script
+
+# Dev mode (watching)
+npm run dev
+
+# Build the library (ES + UMD + CJS)
+npm run build
+
+# Run tests
+npm test
 ```
 
+---
+
 ## 📄 License
 
 MIT
 
-## 🤝 Contributing
-
-Contributions are welcome! Please open an issue or submit a pull request.