diff --git a/development/satellite/architecture.mdx b/development/satellite/architecture.mdx index f181cf9..946e22c 100644 --- a/development/satellite/architecture.mdx +++ b/development/satellite/architecture.mdx @@ -75,7 +75,7 @@ MCP Client Satellite (MCP SDK) │ │ │──── POST /mcp ────────────▶│ (JSON-RPC tools/list) │ │ - │◀─── Tools response ───────│ (Cached tools returned) + │◀─── 2 meta-tools ─────────│ (Hierarchical router) ``` ### Core SDK Components @@ -97,13 +97,17 @@ MCP Client Satellite (MCP SDK) **Supported MCP Methods:** - `initialize` - MCP session initialization (SDK automatic) - `notifications/initialized` - Client initialization complete -- `tools/list` - List cached tools from discovered servers -- `tools/call` - Execute tools routed to appropriate servers +- `tools/list` - List available meta-tools (hierarchical router: 2 tools only) +- `tools/call` - Execute meta-tools or route to actual MCP servers - `resources/list` - List available resources (returns empty array) - `resources/templates/list` - List resource templates (returns empty array) - `prompts/list` - List available prompts (returns empty array) -For detailed information about tool discovery and execution, see [Tool Discovery Implementation](/development/satellite/tool-discovery). + +**Hierarchical Router**: The satellite exposes only 2 meta-tools to MCP clients (`discover_mcp_tools` and `execute_mcp_tool`) instead of all available tools. This solves the MCP context window consumption problem by reducing token usage by 95%+. See [Hierarchical Router Implementation](/development/satellite/hierarchical-router) for details. + + +For detailed information about internal tool discovery and caching, see [Tool Discovery Implementation](/development/satellite/tool-discovery). **Error Handling:** - Standard JSON-RPC 2.0 compliant error responses via SDK @@ -377,7 +381,7 @@ Configuration → Spawn → Monitor → Health Check → Restart/Terminate - **JSON-RPC Version**: 2.0 strict compliance - **HTTP Framework**: Fastify with JSON Schema validation - **Logging**: Pino structured logging with operation tracking -- **Error Handling**: Comprehensive HTTP status code mapping +- **Error Handling**: Complete HTTP status code mapping ### Planned Resource Jailing Specifications - **CPU Limit**: 0.1 cores per MCP server process @@ -410,15 +414,12 @@ curl -X POST "http://localhost:3001/mcp" \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":"1","method":"initialize","params":{}}' -# Test tool discovery -curl -X POST "http://localhost:3001/mcp" \ - -H "Content-Type: application/json" \ - -d '{"jsonrpc":"2.0","id":"2","method":"tools/list","params":{}}' - # Test SSE streaming curl -N -H "Accept: text/event-stream" "http://localhost:3001/mcp" ``` +For testing the hierarchical router (tool discovery and execution), see [Hierarchical Router Implementation](/development/satellite/hierarchical-router). + **MCP Client Configuration:** ```json { diff --git a/development/satellite/hierarchical-router.mdx b/development/satellite/hierarchical-router.mdx new file mode 100644 index 0000000..99efd2b --- /dev/null +++ b/development/satellite/hierarchical-router.mdx @@ -0,0 +1,594 @@ +--- +title: Hierarchical Router Implementation +description: Technical solution to MCP context window consumption. DeployStack's hierarchical router pattern reduces token usage by 99.5% using just 2 meta-tools. +--- + +DeployStack Satellite implements a hierarchical router pattern to solve the MCP context window consumption problem. Instead of exposing hundreds of tools directly to MCP clients, the satellite exposes only 2 meta-tools that enable dynamic tool discovery and execution. + + +**Problem Solved**: Traditional MCP implementations expose all tools directly, consuming 40-80% of the context window before any actual work begins. The hierarchical router reduces this to \<1% while maintaining full functionality. + + +For information about how tools are discovered and cached internally, see [Tool Discovery Implementation](/development/satellite/tool-discovery). + +## The Context Window Problem + +### Traditional MCP Architecture + +When MCP clients connect to servers with many tools, the context window gets consumed by tool definitions: + +``` +Example with 15 MCP servers, each having 10 tools: 150 total tools +Each tool definition consumes approximately 500 tokens: 150 × 500 = 75,000 tokens +Context window total capacity: 200,000 tokens +Available for work: 125,000 tokens (62.5%) +``` + +**Real-world impact:** +- Claude Code: 82,000 tokens consumed by MCP tools (41% of context) +- Industry consensus: 20-40 tools before performance degrades +- Cursor hard limit: 40 tools maximum +- Critical failures: 80+ tools cause suboptimal responses + +### Root Cause + +MCP clients call `tools/list` to discover available tools, and servers respond with complete tool definitions including: +- Tool name +- Description (often 100+ characters) +- Input schema (JSON Schema objects) +- Parameter descriptions +- Examples and constraints + +This metadata is valuable but consumes massive context space when multiplied across many tools. + +## The Hierarchical Router Solution + +### Architecture Overview + +Instead of exposing all tools directly, the satellite exposes only 2 meta-tools: + +``` +┌─────────────────────────────────────────────────────────────┐ +│ MCP Client (Claude Desktop / VS Code) │ +│ │ +│ Connects to: http://satellite.deploystack.io/mcp │ +│ │ +│ Sees: "This server has 2 tools!" │ +│ 1. discover_mcp_tools │ +│ 2. execute_mcp_tool │ +└─────────────────────────────────────────────────────────────┘ + │ + │ MCP Protocol (JSON-RPC) + │ +┌─────────────────────────────▼───────────────────────────────┐ +│ DeployStack Satellite (Hierarchical Router) │ +│ │ +│ Exposes: 2 static meta-tools (NEVER change) │ +│ │ +│ Behind the scenes: │ +│ • Manages 20+ actual MCP servers │ +│ • Each with 5-10 tools = 100+ real tools │ +│ • Search index with Fuse.js │ +│ • Client never knows about this complexity │ +└──────────────────────────────────────────────────────────────┘ +``` + +### Token Reduction + +**Before (Traditional):** +- 150 tools × 500 tokens = 75,000 tokens +- 37.5% of 200k context consumed + +**After (Hierarchical):** +- 2 meta-tools × 175 tokens = 350 tokens +- 0.175% of 200k context consumed +- **99.5% reduction** + +## Meta-Tool Specifications + +### Tool 1: discover_mcp_tools + +**Purpose:** Search for available tools across all connected MCP servers using natural language queries. + +**Definition:** +```typescript +{ + name: "discover_mcp_tools", + description: "Search and discover available MCP tools across all connected servers. Use natural language to find tools (e.g., 'Figma tools', 'PostgreSQL database', 'GitHub repository'). Returns tool paths that can be executed with execute_mcp_tool.", + inputSchema: { + type: "object", + properties: { + query: { + type: "string", + description: "Natural language search query describing what you want to do" + }, + limit: { + type: "number", + description: "Maximum number of results to return (default: 10)", + default: 10 + } + }, + required: ["query"] + } +} +``` + +**Example Request:** +```json +{ + "jsonrpc": "2.0", + "id": "1", + "method": "tools/call", + "params": { + "name": "discover_mcp_tools", + "arguments": { + "query": "github create issue", + "limit": 5 + } + } +} +``` + +**Example Response:** +```json +{ + "jsonrpc": "2.0", + "id": "1", + "result": { + "content": [{ + "type": "text", + "text": { + "tools": [ + { + "tool_path": "github:create_issue", + "description": "Create a new issue in a repository", + "server_name": "github", + "transport": "stdio", + "relevance_score": 0.01 + }, + { + "tool_path": "github:update_issue", + "description": "Update an existing issue", + "server_name": "github", + "transport": "stdio", + "relevance_score": 0.15 + } + ], + "total_found": 2, + "search_time_ms": 3, + "query": "github create issue" + } + }] + } +} +``` + +**Implementation Details:** +- Uses Fuse.js for fuzzy full-text search +- Searches across tool names, descriptions, and server names +- Returns results ranked by relevance score +- Search time: 2-5ms for 100+ tools +- Queries [UnifiedToolDiscoveryManager](/development/satellite/tool-discovery) for tool cache + +### Tool 2: execute_mcp_tool + +**Purpose:** Execute a discovered tool by its path returned from `discover_mcp_tools`. + +**Definition:** +```typescript +{ + name: "execute_mcp_tool", + description: "Execute a discovered MCP tool by its path. Use after discovering tools with discover_mcp_tools. The tool_path format is 'serverName:toolName' (e.g., 'figma:get_file', 'github:create_issue').", + inputSchema: { + type: "object", + properties: { + tool_path: { + type: "string", + description: "Full tool path from discover_mcp_tools (format: serverName:toolName)" + }, + arguments: { + type: "object", + description: "Arguments to pass to the tool (schema varies by tool)" + } + }, + required: ["tool_path", "arguments"] + } +} +``` + +**Example Request:** +```json +{ + "jsonrpc": "2.0", + "id": "2", + "method": "tools/call", + "params": { + "name": "execute_mcp_tool", + "arguments": { + "tool_path": "github:create_issue", + "arguments": { + "repo": "deploystackio/deploystack", + "title": "Test issue", + "body": "Test body" + } + } + } +} +``` + +**Example Response:** +```json +{ + "jsonrpc": "2.0", + "id": "2", + "result": { + "content": [{ + "type": "text", + "text": { + "issue_number": 42, + "url": "https://github.com/deploystackio/deploystack/issues/42" + } + }] + } +} +``` + +**Implementation Details:** +- Parses `tool_path` from external format (`server:tool`) to internal format (`server-tool`) +- Looks up tool in unified cache to determine transport type +- Routes to appropriate handler (stdio or HTTP/SSE) +- Returns result in MCP content format + +## Complete User Flow + +### Step 1: Client Connects + +``` +MCP Client → POST /mcp +{ + "jsonrpc": "2.0", + "method": "initialize", + "params": {...} +} + +Satellite → Client +{ + "result": { + "capabilities": {"tools": {}}, + "serverInfo": {"name": "deploystack-satellite"} + } +} +``` + +**Client knows:** "I connected to a server named deploystack-satellite" + +### Step 2: Client Discovers Available Tools + +``` +MCP Client → POST /mcp +{ + "jsonrpc": "2.0", + "method": "tools/list", + "params": {} +} + +Satellite → Client +{ + "result": { + "tools": [ + { + "name": "discover_mcp_tools", + "description": "Search and discover available MCP tools...", + "inputSchema": {...} + }, + { + "name": "execute_mcp_tool", + "description": "Execute a discovered MCP tool...", + "inputSchema": {...} + } + ] + } +} +``` + +**Client knows:** "This server has 2 tools available" + +### Step 3: User Asks for GitHub Tools + +The AI agent (Claude) decides it needs GitHub tools: + +``` +MCP Client → POST /mcp +{ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "discover_mcp_tools", + "arguments": { + "query": "github create issue", + "limit": 5 + } + } +} + +Satellite Internal Process: +1. Receives search query: "github create issue" +2. Searches Fuse.js index (3ms) +3. Finds matches from cached tools +4. Formats results with external tool_path format + +Satellite → Client +{ + "result": { + "content": [{ + "type": "text", + "text": { + "tools": [ + { + "tool_path": "github:create_issue", + "description": "Create a new issue", + "relevance_score": 0.01 + } + ] + } + }] + } +} +``` + +**Client knows:** "The discovery tool returned some tool paths as strings" + +### Step 4: User Executes Discovered Tool + +The AI agent decides to use `github:create_issue`: + +``` +MCP Client → POST /mcp +{ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "execute_mcp_tool", + "arguments": { + "tool_path": "github:create_issue", + "arguments": { + "repo": "deploystackio/deploystack", + "title": "Test issue" + } + } + } +} + +Satellite Internal Process: +1. Parses tool_path: "github:create_issue" → "github-create_issue" +2. Looks up in cache: transport=stdio, serverName="github-team123-abc456" +3. Routes to ProcessManager for stdio execution +4. Sends JSON-RPC to actual GitHub MCP server process +5. Returns result + +Satellite → Client +{ + "result": { + "content": [{ + "type": "text", + "text": { + "issue_number": 42, + "url": "https://github.com/..." + } + }] + } +} +``` + +**Client knows:** "The execute tool returned a result" + +## Format Conversion + +### External vs Internal Formats + +The satellite uses different tool path formats for different purposes: + +**External Format (User-Facing): `serverName:toolName`** + +Used in: +- `discover_mcp_tools` responses +- `execute_mcp_tool` requests +- Any client-facing communication + +Examples: +- `github:create_issue` +- `figma:get_file` +- `postgres:query` + +Why colon? +- Standard separator in URIs and paths +- Clean, readable format +- Industry convention (npm packages, docker images) + +**Internal Format (Routing): `serverName-toolName`** + +Used in: +- Unified tool cache keys +- Tool discovery manager +- Process routing +- Internal lookups + +Examples: +- `github-create_issue` +- `figma-get_file` +- `postgres-query` + +Why dash? +- Existing codebase convention +- Backward compatibility +- All existing code uses dash format + +### Conversion Logic + +```typescript +// In handleExecuteTool() +const toolPath = "github:create_issue"; // From client + +// Parse external format +const [serverSlug, toolName] = toolPath.split(':'); + +// Convert to internal format +const namespacedToolName = `${serverSlug}-${toolName}`; +// Result: "github-create_issue" + +// Look up in cache +const cachedTool = toolDiscoveryManager.getTool(namespacedToolName); + +// Route to actual MCP server +await executeToolCall(namespacedToolName, toolArguments); +``` + +The conversion is transparent to both clients and actual MCP servers - it's purely a satellite internal concern. + +## Search Implementation + +### Fuse.js Configuration + +```typescript +const fuseOptions = { + threshold: 0.3, // Precise matches (0.0 = exact, 1.0 = anything) + keys: [ + { name: 'toolName', weight: 0.4 }, // 40% weight + { name: 'description', weight: 0.35 }, // 35% weight + { name: 'serverSlug', weight: 0.25 } // 25% weight + ], + includeScore: true, + minMatchCharLength: 2, + useExtendedSearch: true +}; +``` + +### Search Performance + +- **Index Build**: On-demand per search (no stale cache) +- **Search Time**: 2-5ms for 100+ tools +- **Memory**: Zero duplication (queries UnifiedToolDiscoveryManager directly) +- **Accuracy**: Handles typos, partial matches, fuzzy matching + +### Single Source of Truth + +ToolSearchService queries [UnifiedToolDiscoveryManager.getAllTools()](/development/satellite/tool-discovery) directly for every search: + +```typescript +search(query: string, limit: number): SearchResult[] { + // Get fresh tools from single source of truth + const allTools = this.toolDiscoveryManager.getAllTools(); + + // Build Fuse.js index on-demand + const fuse = new Fuse(allTools, fuseOptions); + + // Search and return results + return fuse.search(query).slice(0, limit); +} +``` + +Benefits: +- Always up-to-date (no cache invalidation needed) +- No memory duplication +- Automatic reflection of tool changes + +## Why Tool Notifications Are Irrelevant + +### The Question + +> "Should we implement `notifications/tools/list_changed` when tools are added or removed?" + +### The Answer + +**NO.** The MCP client only sees 2 static meta-tools that NEVER change: +- `discover_mcp_tools` ✅ Always available +- `execute_mcp_tool` ✅ Always available + +**What DOES change behind the scenes:** +- New MCP servers installed → Search index updates automatically +- MCP servers removed → Search index updates automatically +- Tools discovered from new servers → Search index updates automatically + +**But the client never needs to know!** + +When a new MCP server is installed: +1. ✅ Backend sends configuration update to satellite +2. ✅ Satellite spawns new MCP server process (if stdio) +3. ✅ Tool discovery runs automatically +4. ✅ Search index refreshed (next search uses new tools) +5. ❌ **Client is NOT notified** (doesn't need to be) + +Next time the client calls `discover_mcp_tools`, the new tools are automatically included in search results. **No notification needed.** + +## Performance Characteristics + +### Token Consumption + +| Metric | Traditional | Hierarchical | Reduction | +|--------|-------------|--------------|-----------| +| Tools Exposed | 150 | 2 | 98.7% | +| Tokens Consumed | 75,000 | 350 | 99.5% | +| Context Available | 62.5% | 99.8% | +37.3% | + +### Search Performance + +- **Discovery Latency**: 2-5ms (including Fuse.js index build) +- **Execution Latency**: \<1ms (routing overhead only) +- **Memory Overhead**: ~1KB per cached tool +- **Scalability**: No degradation up to 500+ tools + +### Real-World Impact + +**Claude Code Example:** +- Before: 82,000 tokens (41%) consumed by MCP tools +- After: 350 tokens (0.175%) consumed by meta-tools +- Result: **81,650 tokens freed for actual work** + +## Implementation Status + + +**Status**: ✅ Fully Operational + +Both meta-tools are implemented and production-ready: +- `discover_mcp_tools`: Full-text search with Fuse.js +- `execute_mcp_tool`: Complete routing for stdio and HTTP/SSE transports + + +### Code Locations + +**Core Implementation:** +- `/services/satellite/src/core/mcp-server-wrapper.ts` - Meta-tool handlers +- `/services/satellite/src/services/tool-search-service.ts` - Search implementation +- `/services/satellite/src/services/unified-tool-discovery-manager.ts` - Tool cache + +**Key Methods:** +- `setupMcpServer()` - Registers 2 meta-tools instead of all tools +- `handleDiscoverTools()` - Implements discovery logic +- `handleExecuteTool()` - Implements execution routing + +## Benefits Summary + +**For Users:** +- 95%+ more context available for actual work +- Natural language tool discovery +- No performance degradation with many tools +- Transparent - works like any MCP server + +**For Developers:** +- Simple 2-tool interface +- Automatic tool discovery +- No client modifications needed +- Standard MCP protocol compliance + +**For Operations:** +- Scales to hundreds of tools +- No memory explosion +- Fast search performance +- Easy to monitor and debug + +## Related Documentation + +- [Tool Discovery Implementation](/development/satellite/tool-discovery) - Internal tool caching and discovery +- [MCP Transport Protocols](/development/satellite/mcp-transport) - How clients connect +- [Process Management](/development/satellite/process-management) - stdio server lifecycle +- [Architecture Overview](/development/satellite/architecture) - Complete satellite design diff --git a/development/satellite/mcp-transport.mdx b/development/satellite/mcp-transport.mdx index 2866050..ef61394 100644 --- a/development/satellite/mcp-transport.mdx +++ b/development/satellite/mcp-transport.mdx @@ -4,7 +4,7 @@ description: Official MCP SDK transport implementation for external client integ --- -Satellite uses the official `@modelcontextprotocol/sdk` to provide MCP client communication. This ensures full protocol compliance and seamless compatibility with all MCP clients including VS Code, Claude, and MCP Inspector. +Satellite uses the official `@modelcontextprotocol/sdk` to provide MCP client communication. This ensures full protocol compliance and works with all MCP clients including VS Code, Claude, and MCP Inspector. ## Transport Overview @@ -159,13 +159,6 @@ For detailed information about tool discovery and execution, see [Tool Discovery -d '{"jsonrpc":"2.0","id":"1","method":"initialize","params":{}}' ``` -3. **Test Tools Discovery:** - ```bash - curl -X POST "http://localhost:3001/mcp" \ - -H "Content-Type: application/json" \ - -d '{"jsonrpc":"2.0","id":"2","method":"tools/list","params":{}}' - ``` - ### Protocol Features The official MCP SDK provides: diff --git a/development/satellite/tool-discovery.mdx b/development/satellite/tool-discovery.mdx index 7472275..bf67706 100644 --- a/development/satellite/tool-discovery.mdx +++ b/development/satellite/tool-discovery.mdx @@ -4,13 +4,15 @@ description: Technical implementation of MCP server tool discovery in DeployStac --- -DeployStack Satellite implements automatic tool discovery from MCP servers across both HTTP/SSE remote endpoints and stdio subprocess servers. This unified system provides dynamic tool availability without manual configuration, enabling MCP clients to discover and execute tools through the satellite's interface. +DeployStack Satellite implements automatic tool discovery from MCP servers across both HTTP/SSE remote endpoints and stdio subprocess servers. This unified system provides dynamic tool availability without manual configuration. -**Current Implementation**: Tool discovery fully supports both HTTP/SSE remote MCP servers and stdio subprocess servers through a unified architecture. The `UnifiedToolDiscoveryManager` coordinates discovery across both transport types, merging tools into a single cache for seamless client access. +**Current Implementation**: Tool discovery fully supports both HTTP/SSE remote MCP servers and stdio subprocess servers through a unified architecture. The `UnifiedToolDiscoveryManager` coordinates discovery across both transport types, merging tools into a single cache. + +This document focuses on the **internal** tool discovery mechanism. To learn how tools are exposed to MCP clients through the hierarchical router pattern, see [Hierarchical Router Implementation](/development/satellite/hierarchical-router). -For information about the overall satellite architecture, see [Satellite Architecture Design](/development/satellite/architecture). For details about the MCP transport protocols that expose discovered tools, see [MCP Transport Protocols](/development/satellite/mcp-transport). +The overall satellite architecture is documented in [Satellite Architecture Design](/development/satellite/architecture). MCP transport protocol details can be found in [MCP Transport Protocols](/development/satellite/mcp-transport). ## Technical Overview @@ -45,9 +47,9 @@ Tool discovery operates through three coordinated managers that handle different ### Core Components **UnifiedToolDiscoveryManager:** -- Coordinates discovery across HTTP/SSE and stdio transport types -- Merges tools from both managers into unified cache -- Routes discovery requests based on transport type +- Coordinates tool discovery across both HTTP/SSE and stdio transport types +- Merges discovered tools from both managers into a unified cache +- Routes discovery requests to the appropriate transport type - Provides single interface for MCP protocol handlers **RemoteToolDiscoveryManager:** @@ -249,26 +251,6 @@ curl http://localhost:3001/api/status/debug **Security Notice**: The debug endpoint exposes detailed system information. Disable in production with `DEPLOYSTACK_STATUS_SHOW_MCP_DEBUG_ROUTE=false`. -### Testing Strategies - -**Unified Testing:** -```bash -# Test tool listing (shows both HTTP and stdio tools) -curl -X POST http://localhost:3001/mcp \ - -H "Content-Type: application/json" \ - -d '{"jsonrpc":"2.0","id":"1","method":"tools/list","params":{}}' - -# Test HTTP tool execution -curl -X POST http://localhost:3001/mcp \ - -H "Content-Type: application/json" \ - -d '{"jsonrpc":"2.0","id":"2","method":"tools/call","params":{"name":"context7-resolve-library-id","arguments":{"libraryName":"react"}}}' - -# Test stdio tool execution -curl -X POST http://localhost:3001/mcp \ - -H "Content-Type: application/json" \ - -d '{"jsonrpc":"2.0","id":"3","method":"tools/call","params":{"name":"filesystem-read_file","arguments":{"path":"/tmp/test.txt"}}}' -``` - ## Performance Characteristics ### HTTP/SSE Performance diff --git a/docs.json b/docs.json index d9cde88..0114c5f 100644 --- a/docs.json +++ b/docs.json @@ -186,6 +186,7 @@ "group": "MCP Server Management", "pages": [ "/development/satellite/mcp-transport", + "/development/satellite/hierarchical-router", "/development/satellite/process-management", "/development/satellite/team-isolation", "/development/satellite/tool-discovery", diff --git a/package-lock.json b/package-lock.json index 9a2482e..e98bc5b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,7 +8,7 @@ "name": "deploystack-io-documentation", "version": "0.0.0-development", "devDependencies": { - "@semantic-release/github": "^11.0.5", + "@semantic-release/github": "^12.0.1", "@types/node": "24.9.1", "markdownlint-cli": "^0.45.0", "markdownlint-cli2": "^0.18.1", @@ -264,13 +264,13 @@ "license": "MIT" }, "node_modules/@octokit/plugin-paginate-rest": { - "version": "13.0.1", - "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-13.0.1.tgz", - "integrity": "sha512-m1KvHlueScy4mQJWvFDCxFBTIdXS0K1SgFGLmqHyX90mZdCIv6gWBbKRhatxRjhGlONuTK/hztYdaqrTXcFZdQ==", + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-14.0.0.tgz", + "integrity": "sha512-fNVRE7ufJiAA3XUrha2omTA39M6IXIc6GIZLvlbsm8QOQCYvpq/LkMNGyFlB1d8hTDzsAXa3OKtybdMAYsV/fw==", "dev": true, "license": "MIT", "dependencies": { - "@octokit/types": "^14.1.0" + "@octokit/types": "^16.0.0" }, "engines": { "node": ">= 20" @@ -279,6 +279,23 @@ "@octokit/core": ">=6" } }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": { + "version": "27.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-27.0.0.tgz", + "integrity": "sha512-whrdktVs1h6gtR+09+QsNk2+FO+49j6ga1c55YZudfEG+oKJVvJLQi3zkOm5JjiUXAagWK2tI2kTGKJ2Ys7MGA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": { + "version": "16.0.0", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-16.0.0.tgz", + "integrity": "sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@octokit/openapi-types": "^27.0.0" + } + }, "node_modules/@octokit/plugin-retry": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-8.0.1.tgz", @@ -446,31 +463,31 @@ } }, "node_modules/@semantic-release/github": { - "version": "11.0.5", - "resolved": "https://registry.npmjs.org/@semantic-release/github/-/github-11.0.5.tgz", - "integrity": "sha512-wJamzHteXwBdopvkTD6BJjPz1UHLm20twlVCSMA9zpd3B5KrOQX137jfTbNJT6ZVz3pXtg0S1DroQl4wifJ4WQ==", + "version": "12.0.1", + "resolved": "https://registry.npmjs.org/@semantic-release/github/-/github-12.0.1.tgz", + "integrity": "sha512-BSC7Ko6aRPnH8ttVBpd3gC98LTiyPdmrmX4qHilLw5EZqVrXrXwcKp/JKUC5hgm0XpJACR3nPjgbfOjTJ75PIA==", "dev": true, "license": "MIT", "dependencies": { "@octokit/core": "^7.0.0", - "@octokit/plugin-paginate-rest": "^13.0.0", + "@octokit/plugin-paginate-rest": "^14.0.0", "@octokit/plugin-retry": "^8.0.0", "@octokit/plugin-throttling": "^11.0.0", "@semantic-release/error": "^4.0.0", "aggregate-error": "^5.0.0", "debug": "^4.3.4", "dir-glob": "^3.0.1", - "globby": "^14.0.0", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.0", "issue-parser": "^7.0.0", "lodash-es": "^4.17.21", "mime": "^4.0.0", "p-filter": "^4.0.0", + "tinyglobby": "^0.2.14", "url-join": "^5.0.0" }, "engines": { - "node": ">=20.8.1" + "node": "^22.14.0 || >= 24.10.0" }, "peerDependencies": { "semantic-release": ">=24.1.0" @@ -7113,6 +7130,74 @@ "node": ">=20.8.1" } }, + "node_modules/semantic-release/node_modules/@octokit/openapi-types": { + "version": "26.0.0", + "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-26.0.0.tgz", + "integrity": "sha512-7AtcfKtpo77j7Ts73b4OWhOZHTKo/gGY8bB3bNBQz4H+GRSWqx2yvj8TXRsbdTE0eRmYmXOEY66jM7mJ7LzfsA==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/semantic-release/node_modules/@octokit/plugin-paginate-rest": { + "version": "13.2.1", + "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-13.2.1.tgz", + "integrity": "sha512-Tj4PkZyIL6eBMYcG/76QGsedF0+dWVeLhYprTmuFVVxzDW7PQh23tM0TP0z+1MvSkxB29YFZwnUX+cXfTiSdyw==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@octokit/types": "^15.0.1" + }, + "engines": { + "node": ">= 20" + }, + "peerDependencies": { + "@octokit/core": ">=6" + } + }, + "node_modules/semantic-release/node_modules/@octokit/types": { + "version": "15.0.2", + "resolved": "https://registry.npmjs.org/@octokit/types/-/types-15.0.2.tgz", + "integrity": "sha512-rR+5VRjhYSer7sC51krfCctQhVTmjyUMAaShfPB8mscVa8tSoLyon3coxQmXu0ahJoLVWl8dSGD/3OGZlFV44Q==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@octokit/openapi-types": "^26.0.0" + } + }, + "node_modules/semantic-release/node_modules/@semantic-release/github": { + "version": "11.0.6", + "resolved": "https://registry.npmjs.org/@semantic-release/github/-/github-11.0.6.tgz", + "integrity": "sha512-ctDzdSMrT3H+pwKBPdyCPty6Y47X8dSrjd3aPZ5KKIKKWTwZBE9De8GtsH3TyAlw3Uyo2stegMx6rJMXKpJwJA==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@octokit/core": "^7.0.0", + "@octokit/plugin-paginate-rest": "^13.0.0", + "@octokit/plugin-retry": "^8.0.0", + "@octokit/plugin-throttling": "^11.0.0", + "@semantic-release/error": "^4.0.0", + "aggregate-error": "^5.0.0", + "debug": "^4.3.4", + "dir-glob": "^3.0.1", + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.0", + "issue-parser": "^7.0.0", + "lodash-es": "^4.17.21", + "mime": "^4.0.0", + "p-filter": "^4.0.0", + "tinyglobby": "^0.2.14", + "url-join": "^5.0.0" + }, + "engines": { + "node": ">=20.8.1" + }, + "peerDependencies": { + "semantic-release": ">=24.1.0" + } + }, "node_modules/semver": { "version": "7.7.2", "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", @@ -7747,6 +7832,54 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinyglobby/node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/tinyglobby/node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, "node_modules/to-regex-range": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", diff --git a/package.json b/package.json index 6d8cfa5..035e08d 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,7 @@ }, "dependencies": {}, "devDependencies": { - "@semantic-release/github": "^11.0.5", + "@semantic-release/github": "^12.0.1", "@types/node": "24.9.1", "markdownlint-cli": "^0.45.0", "markdownlint-cli2": "^0.18.1",