@toolsdk.ai/registry 1.0.102 → 1.0.103

package/dist/api/index.js

@@ -1,15 +1,43 @@
+import fs from "node:fs/promises";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import { swaggerUI } from "@hono/swagger-ui";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import dotenv from "dotenv";
+import { searchRoutes } from "../search/search-route";
+import searchService from "../search/search-service";
 import { packageRoutes } from "./package-route";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 dotenv.config({ path: path.resolve(process.cwd(), ".env.local") });
 dotenv.config({ path: path.resolve(process.cwd(), ".env") });
+const initializeSearchService = async () => {
+    try {
+        await searchService.initialize();
+        console.log("🔍 Search service initialized");
+    }
+    catch (error) {
+        console.warn("⚠️  Search service initialization failed:", error.message);
+        console.log("💡 Install and start MeiliSearch to enable enhanced search features");
+    }
+};
 const app = new OpenAPIHono();
 app.route("/api/v1", packageRoutes);
-app.get("/", (c) => {
-    return c.text("MCP Registry API Server is running!");
+if (process.env.ENABLE_SEARCH === "true") {
+    initializeSearchService().catch(console.error);
+    app.route("/api/v1", searchRoutes);
+}
+app.get("/", async (c) => {
+    try {
+        const htmlPath = path.join(__dirname, "..", "search", "search.html");
+        const html = await fs.readFile(htmlPath, "utf8");
+        return c.html(html);
+    }
+    catch (error) {
+        console.error("Failed to load home page:", error);
+        return c.text("MCP Registry API Server is running!");
+    }
 });
 app.get("/api/meta", (c) => {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -31,7 +59,7 @@ app.onError((err, c) => {
     console.error("Server Error:", err);
     return c.json({ success: false, code: 500, message: "Internal server error" }, 500);
 });
-const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3000;
+const port = process.env.MCP_SERVER_PORT ? parseInt(process.env.MCP_SERVER_PORT, 10) : 3003;
 console.log(`Server is running on: http://localhost:${port}`);
 serve({
     fetch: app.fetch,

package/dist/api/package-handler.d.ts

@@ -9,11 +9,11 @@ export declare const packageHandler: {
         success: boolean;
         code: number;
         message: string;
-    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
-    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
@@ -77,11 +77,11 @@ export declare const packageHandler: {
         success: boolean;
         code: number;
         message: string;
-    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;
-    }, 400, "json">) | (globalThis.Response & import("hono").TypedResponse<{
+    }, 404, "json">) | (globalThis.Response & import("hono").TypedResponse<{
         success: boolean;
         code: number;
         message: string;

package/dist/api/package-so.js

@@ -1,6 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { getMcpClient, getPackageConfigByKey, typedAllPackagesList } from "../helper.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class PackageSO {
     async executeTool(request) {
         const mcpServerConfig = getPackageConfigByKey(request.packageName);

package/dist/helper.d.ts

@@ -11,6 +11,7 @@ export declare const typedAllPackagesList: Record<string, {
     }> | undefined;
 }>;
 export declare function getPackageConfigByKey(packageKey: string): MCPServerPackageConfig;
+export declare function getPackageJSON(packageName: string): any;
 export declare function getMcpClient(mcpServerConfig: MCPServerPackageConfig, env?: Record<string, string>): Promise<{
     client: Client<{
         method: string;

package/dist/helper.js

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 import toml from "@iarna/toml";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
@@ -8,6 +9,8 @@ import axios from "axios";
 import semver from "semver";
 import allPackagesList from "../indexes/packages-list.json";
 import { MCPServerPackageConfigSchema, PackagesListSchema } from "./schema";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export const typedAllPackagesList = PackagesListSchema.parse(allPackagesList);
 export function getPackageConfigByKey(packageKey) {
     const value = typedAllPackagesList[packageKey];
@@ -20,8 +23,12 @@ export function getPackageConfigByKey(packageKey) {
     const mcpServerConfig = MCPServerPackageConfigSchema.parse(JSON.parse(jsonStr));
     return mcpServerConfig;
 }
-function getPackageJSON(packageName) {
+export function getPackageJSON(packageName) {
     const packageJSONFilePath = `${__dirname}/../node_modules/${packageName}/package.json`;
+    // Check if the package exists in node_modules
+    if (!fs.existsSync(packageJSONFilePath)) {
+        throw new Error(`Package '${packageName}' not found in node_modules. Install it first with: pnpm add ${packageName}`);
+    }
     const packageJSONStr = fs.readFileSync(packageJSONFilePath, "utf8");
     const packageJSON = JSON.parse(packageJSONStr);
     return packageJSON;
@@ -100,6 +107,7 @@ export function updatePackageJsonDependencies({ packageDeps, enableValidation =
         "@hono/swagger-ui": "^0.5.2",
         "@hono/zod-openapi": "^0.16.4",
         "@iarna/toml": "^2.2.5",
+        meilisearch: "^0.33.0",
         lodash: "^4.17.21",
         zod: "^3.23.30",
         axios: "^1.9.0",

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

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

package/dist/search/search-route.js

@@ -0,0 +1,305 @@
+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

@@ -0,0 +1,120 @@
+/**
+ * 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;