@toolsdk.ai/registry 1.0.113 → 1.0.115

package/dist/search/search-route.d.ts

@@ -1,3 +0,0 @@
-import { OpenAPIHono } from "@hono/zod-openapi";
-declare const searchRoutes: OpenAPIHono<import("hono").Env, {}, "/">;
-export { searchRoutes };

package/dist/search/search-route.js

@@ -1,305 +0,0 @@
-import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
-import { BaseResponseSchema } from "../schema";
-import { createErrorResponse, createResponse, createRouteResponses } from "../utils";
-import searchService from "./search-service";
-const searchRoutes = new OpenAPIHono();
-// Define search query parameter schema
-const searchQuerySchema = z.object({
-    q: z.string().openapi({
-        description: "Search query",
-        example: "database",
-    }),
-    limit: z.coerce.number().min(1).max(100).optional().openapi({
-        description: "Limit the number of results",
-        example: 20,
-    }),
-    offset: z.coerce.number().min(0).optional().openapi({
-        description: "Offset for pagination",
-        example: 0,
-    }),
-    category: z.string().optional().openapi({
-        description: "Filter by category",
-        example: "databases",
-    }),
-});
-// Define search result response schema
-const searchResultSchema = z
-    .object({
-    id: z.string(),
-    name: z.string(),
-    packageName: z.string(),
-    description: z.string(),
-    category: z.string(),
-    validated: z.boolean(),
-    author: z.string(),
-    toolCount: z.number(),
-    hasTools: z.boolean(),
-    popularity: z.number(),
-})
-    .openapi("SearchResult");
-const searchResponseSchema = BaseResponseSchema.extend({
-    data: z
-        .object({
-        hits: z.array(searchResultSchema),
-        query: z.string(),
-        processingTimeMs: z.number(),
-        limit: z.number(),
-        offset: z.number(),
-        estimatedTotalHits: z.number(),
-    })
-        .optional(),
-}).openapi("SearchResponse");
-// Search route definition
-const searchRoute = createRoute({
-    method: "get",
-    path: "/search",
-    request: {
-        query: searchQuerySchema,
-    },
-    responses: createRouteResponses(searchResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(searchRoute, async (c) => {
-    try {
-        const { q, limit, offset, category } = c.req.valid("query");
-        // Build filter condition
-        const filter = category ? `category = '${category}'` : undefined;
-        // Execute search
-        const results = await searchService.search(q, {
-            limit,
-            offset,
-            filter,
-        });
-        const response = createResponse(results);
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Search failed:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Search failed", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Define suggest query parameter schema
-const suggestQuerySchema = z.object({
-    q: z.string().openapi({
-        description: "Suggestion query",
-        example: "data",
-    }),
-    limit: z.coerce.number().min(1).max(20).optional().openapi({
-        description: "Limit the number of results",
-        example: 10,
-    }),
-});
-// Define suggest result response schema
-const suggestResultSchema = z
-    .object({
-    name: z.string(),
-    packageName: z.string(),
-    category: z.string(),
-    highlighted: z.string(),
-})
-    .openapi("SuggestResult");
-const suggestResponseSchema = BaseResponseSchema.extend({
-    data: z
-        .object({
-        suggestions: z.array(suggestResultSchema),
-    })
-        .optional(),
-}).openapi("SuggestResponse");
-// Search suggest route definition
-const suggestRoute = createRoute({
-    method: "get",
-    path: "/search/suggest",
-    request: {
-        query: suggestQuerySchema,
-    },
-    responses: createRouteResponses(suggestResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(suggestRoute, async (c) => {
-    try {
-        const { q, limit } = c.req.valid("query");
-        const suggestions = await searchService.suggest(q, limit);
-        const response = createResponse({ suggestions });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to get suggestions:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to get suggestions");
-        return c.json(errorResponse, 400);
-    }
-});
-// Define facets response schema
-const facetsResponseSchema = BaseResponseSchema.extend({
-    data: z
-        .object({
-        categories: z.record(z.string(), z.number()).optional(),
-        authors: z.record(z.string(), z.number()).optional(),
-        validated: z.record(z.string(), z.number()).optional(),
-    })
-        .optional(),
-}).openapi("FacetsResponse");
-// Facets route definition
-const facetsRoute = createRoute({
-    method: "get",
-    path: "/search/facets",
-    responses: createRouteResponses(facetsResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(facetsRoute, async (c) => {
-    try {
-        // Get facets information
-        const facets = await searchService.getFacets();
-        const response = createResponse({
-            categories: facets === null || facets === void 0 ? void 0 : facets.category,
-            authors: facets === null || facets === void 0 ? void 0 : facets.author,
-            validated: facets === null || facets === void 0 ? void 0 : facets.validated,
-        });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to get facets:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to get facets", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Define health check response schema
-const healthResponseSchema = BaseResponseSchema.extend({
-    data: z
-        .object({
-        status: z.string(),
-        host: z.string(),
-        initialized: z.boolean(),
-        indexName: z.string(),
-        documentCount: z.number(),
-    })
-        .optional(),
-}).openapi("HealthResponse");
-// Health check route definition
-const healthRoute = createRoute({
-    method: "get",
-    path: "/search/health",
-    responses: createRouteResponses(healthResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(healthRoute, async (c) => {
-    try {
-        // Perform health check
-        const health = await searchService.healthCheck();
-        const response = createResponse(health);
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Health check failed:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Health check failed", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Define management response schema
-const managementResponseSchema = BaseResponseSchema.extend({
-    data: z
-        .object({
-        message: z.string(),
-        details: z.any().optional(),
-    })
-        .optional(),
-}).openapi("ManagementResponse");
-// Initialize search service route definition
-const initRoute = createRoute({
-    method: "post",
-    path: "/search/manage/init",
-    responses: createRouteResponses(managementResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(initRoute, async (c) => {
-    try {
-        // Initialize search service
-        await searchService.initialize();
-        const response = createResponse({
-            message: "Search service initialized successfully",
-        });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to initialize search service:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to initialize search service", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Index packages route definition
-const indexRoute = createRoute({
-    method: "post",
-    path: "/search/manage/index",
-    responses: createRouteResponses(managementResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(indexRoute, async (c) => {
-    try {
-        // Index all packages
-        const stats = await searchService.indexPackages();
-        const response = createResponse({
-            message: `Indexed ${stats.numberOfDocuments} documents`,
-            details: stats,
-        });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to index packages:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to index packages", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Clear index route definition
-const clearRoute = createRoute({
-    method: "post",
-    path: "/search/manage/clear",
-    responses: createRouteResponses(managementResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(clearRoute, async (c) => {
-    try {
-        // Clear the index
-        await searchService.clearIndex();
-        const response = createResponse({
-            message: "Index cleared successfully",
-        });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to clear index:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to clear index", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-// Get index stats route definition
-const statsRoute = createRoute({
-    method: "get",
-    path: "/search/manage/stats",
-    responses: createRouteResponses(managementResponseSchema, {
-        includeErrorResponses: true,
-    }),
-});
-searchRoutes.openapi(statsRoute, async (c) => {
-    try {
-        // Get index statistics
-        const stats = await searchService.getStats();
-        const response = createResponse({
-            message: "Index statistics retrieved successfully",
-            details: stats,
-        });
-        return c.json(response, 200);
-    }
-    catch (error) {
-        console.error("Failed to get index statistics:", error.stack);
-        const errorResponse = createErrorResponse(error.message || "Failed to get index statistics", 500);
-        return c.json(errorResponse, 500);
-    }
-});
-export { searchRoutes };

package/dist/search/search-service.d.ts

@@ -1,120 +0,0 @@
-/**
- * MeiliSearch Service for Awesome MCP Registry
- * Handles search indexing and querying for MCP packages
- */
-import { type Index, MeiliSearch } from "meilisearch";
-interface PackageData {
-    name?: string;
-    description?: string;
-    category?: string;
-    validated?: boolean;
-    tools?: Record<string, {
-        description?: string;
-    }>;
-    path?: string;
-}
-interface SearchOptions {
-    limit?: number;
-    offset?: number;
-    filter?: string | string[];
-    sort?: string[];
-    matchingStrategy?: string;
-}
-interface SearchResults {
-    hits: unknown[];
-    query: string;
-    processingTimeMs: number;
-    limit: number;
-    offset: number;
-    estimatedTotalHits: number;
-}
-interface IndexStats {
-    numberOfDocuments: number;
-    isIndexing: boolean;
-    fieldDistribution: Record<string, number>;
-}
-declare class SearchService {
-    private host;
-    private apiKey;
-    private indexName;
-    protected client: MeiliSearch;
-    protected _index: Index | null;
-    protected isInitialized: boolean;
-    constructor(indexName?: string);
-    /**
-     * Get the initialization status
-     */
-    getIsInitialized(): boolean;
-    /**
-     * Get the MeiliSearch client
-     */
-    getClient(): MeiliSearch;
-    get index(): Index | null;
-    set index(value: Index | null);
-    initialize(): Promise<void>;
-    /**
-     * Configure search index settings for optimal MCP package search
-     */
-    configureIndex(): Promise<void>;
-    /**
-     * Transform package data for search indexing
-     */
-    transformPackageForIndex(packageName: string, packageData: PackageData): Record<string, unknown>;
-    /**
-     * Create a safe ID for MeiliSearch (alphanumeric, hyphens, underscores only)
-     */
-    createSafeId(packageName: string): string;
-    /**
-     * Calculate a popularity score for ranking
-     */
-    calculatePopularityScore(packageData: PackageData): number;
-    /**
-     * Extract author from package name
-     */
-    extractAuthor(packageName: string): string;
-    /**
-     * Extract relevant keywords from package data
-     */
-    extractKeywords(packageData: PackageData, packageName: string): string;
-    /**
-     * Index all packages from the packages-list.json file
-     */
-    indexPackages(): Promise<IndexStats>;
-    /**
-     * Search packages with advanced options
-     */
-    search(query: string, options?: SearchOptions): Promise<SearchResults>;
-    /**
-     * Get search suggestions/autocomplete
-     */
-    suggest(query: string, limit?: number): Promise<{
-        name: string;
-        packageName: string;
-        category: string;
-        highlighted: string;
-    }[]>;
-    /**
-     * Get faceted search results (for filters)
-     */
-    getFacets(): Promise<Record<string, unknown> | undefined>;
-    /**
-     * Get index statistics
-     */
-    getStats(): Promise<IndexStats>;
-    /**
-     * Clear the index
-     */
-    clearIndex(): Promise<void>;
-    /**
-     * Health check for the search service
-     */
-    healthCheck(): Promise<{
-        status: string;
-        host: string;
-        initialized: boolean;
-        indexName: string;
-        documentCount: number;
-    }>;
-}
-declare const searchService: SearchService;
-export default searchService;

package/dist/search/search.test.js

@@ -1,100 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import searchService from "./search-service";
-// Mock the MeiliSearch client
-vi.mock("meilisearch", () => {
-    return {
-        MeiliSearch: vi.fn().mockImplementation(() => {
-            const mockIndex = {
-                updateSettings: vi.fn().mockResolvedValue({ taskUid: "settings-task" }),
-                addDocuments: vi.fn().mockResolvedValue({ taskUid: "documents-task" }),
-                getStats: vi.fn().mockResolvedValue({
-                    numberOfDocuments: 100,
-                    isIndexing: false,
-                    fieldDistribution: {},
-                }),
-                search: vi.fn().mockResolvedValue({
-                    hits: [{ id: "1", name: "Test Package" }],
-                    query: "test",
-                    processingTimeMs: 10,
-                    limit: 20,
-                    offset: 0,
-                    estimatedTotalHits: 1,
-                }),
-                getTask: vi.fn().mockResolvedValue({ status: "succeeded" }),
-                deleteAllDocuments: vi.fn().mockResolvedValue({ taskUid: "clear-task" }),
-            };
-            return {
-                health: vi.fn().mockResolvedValue({ status: "available" }),
-                createIndex: vi.fn().mockResolvedValue({ uid: "test-task" }),
-                getIndex: vi.fn().mockResolvedValue(mockIndex),
-                index: vi.fn().mockReturnValue(mockIndex),
-                waitForTask: vi.fn().mockResolvedValue({ status: "succeeded" }),
-            };
-        }),
-    };
-});
-// Mock fs module
-vi.mock("node:fs/promises", () => {
-    return {
-        default: {
-            readFile: vi.fn().mockResolvedValue(JSON.stringify({
-                "@test/package": {
-                    name: "Test Package",
-                    description: "A test package",
-                },
-            })),
-        },
-    };
-});
-describe("SearchService - MCP Registry Search Service Test", () => {
-    it("should initialize search service successfully", async () => {
-        const result = await searchService.initialize();
-        expect(result).toBeUndefined();
-    });
-    it("should transform package data for indexing", () => {
-        const packageName = "@test/package";
-        const packageData = {
-            name: "Test Package",
-            description: "A test package",
-            category: "testing",
-            validated: true,
-            tools: {
-                "test-tool": { description: "A test tool" },
-            },
-        };
-        const result = searchService.transformPackageForIndex(packageName, packageData);
-        expect(result).toEqual({
-            id: "at-test-package",
-            name: "Test Package",
-            packageName: "@test/package",
-            description: "A test package",
-            category: "testing",
-            validated: true,
-            author: "test",
-            tools: "test-tool A test tool",
-            toolCount: 1,
-            hasTools: true,
-            keywords: expect.any(String),
-            popularity: expect.any(Number),
-            path: "",
-        });
-    });
-    it("should perform search successfully", async () => {
-        // First initialize the service
-        await searchService.initialize();
-        // Mock the search result
-        const mockResult = {
-            hits: [{ id: "1", name: "Test Package" }],
-            query: "test",
-            processingTimeMs: 10,
-            limit: 20,
-            offset: 0,
-            estimatedTotalHits: 1,
-        };
-        if (searchService.index) {
-            searchService.index.search = vi.fn().mockResolvedValue(mockResult);
-        }
-        const result = await searchService.search("test");
-        expect(result).toEqual(mockResult);
-    });
-});

package/dist/types.d.ts

@@ -1,27 +0,0 @@
-import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import type { z } from "zod";
-import type { BaseResponseSchema, CategoriesResponseSchema, CategoryConfigSchema, ErrorResponseSchema, ExecuteToolResponseSchema, FeaturedResponseSchema, MCPServerPackageConfigSchema, PackageConfigSchema, PackageDetailDataSchema, PackageDetailResponseSchema, PackagesListResponseSchema, PackagesListSchema, ToolDataSchema, ToolExecuteSchema, ToolsResponseSchema } from "./schema";
-export type MCPServerPackageConfig = z.infer<typeof MCPServerPackageConfigSchema>;
-export type PackageConfig = z.infer<typeof PackageConfigSchema>;
-export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
-export type PackagesList = z.infer<typeof PackagesListSchema>;
-export type ToolExecute = z.infer<typeof ToolExecuteSchema>;
-export interface Response<T> {
-    success: boolean;
-    code: number;
-    message: string;
-    data?: T;
-}
-export type MCPServerPackageConfigWithTools = MCPServerPackageConfig & {
-    tools?: Tool[];
-};
-export type BaseResponse = z.infer<typeof BaseResponseSchema>;
-export type FeaturedResponse = z.infer<typeof FeaturedResponseSchema>;
-export type CategoriesResponse = z.infer<typeof CategoriesResponseSchema>;
-export type PackagesListResponse = z.infer<typeof PackagesListResponseSchema>;
-export type PackageDetailData = z.infer<typeof PackageDetailDataSchema>;
-export type PackageDetailResponse = z.infer<typeof PackageDetailResponseSchema>;
-export type ToolData = z.infer<typeof ToolDataSchema>;
-export type ToolsResponse = z.infer<typeof ToolsResponseSchema>;
-export type ExecuteToolResponse = z.infer<typeof ExecuteToolResponseSchema>;
-export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;