@toolsdk.ai/registry 1.0.113 → 1.0.115

package/dist/domains/search/search-route.js

@@ -0,0 +1,101 @@
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { createRouteResponses } from "../../shared/utils/response-util";
+import { searchHandler } from "./search-handler";
+import { facetsResponseSchema, healthResponseSchema, managementResponseSchema, searchQuerySchema, searchResponseSchema, suggestQuerySchema, suggestResponseSchema, } from "./search-schema";
+export const searchRoutes = new OpenAPIHono();
+const searchRoute = createRoute({
+    method: "get",
+    path: "/",
+    request: {
+        query: searchQuerySchema,
+    },
+    responses: createRouteResponses(searchResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(searchRoute, async (c) => {
+    const { q, limit, offset, category } = c.req.valid("query");
+    const result = await searchHandler.search({ q, limit, offset, category });
+    return c.json(result, 200);
+});
+const suggestRoute = createRoute({
+    method: "get",
+    path: "/suggest",
+    request: {
+        query: suggestQuerySchema,
+    },
+    responses: createRouteResponses(suggestResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(suggestRoute, async (c) => {
+    const { q, limit } = c.req.valid("query");
+    const result = await searchHandler.suggest(q, limit);
+    return c.json(result, 200);
+});
+const facetsRoute = createRoute({
+    method: "get",
+    path: "/facets",
+    responses: createRouteResponses(facetsResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(facetsRoute, async (c) => {
+    const result = await searchHandler.getFacets();
+    return c.json(result, 200);
+});
+const healthRoute = createRoute({
+    method: "get",
+    path: "/health",
+    responses: createRouteResponses(healthResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(healthRoute, async (c) => {
+    const result = await searchHandler.healthCheck();
+    return c.json(result, 200);
+});
+const initRoute = createRoute({
+    method: "post",
+    path: "/manage/init",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(initRoute, async (c) => {
+    const result = await searchHandler.initialize();
+    return c.json(result, 200);
+});
+const indexRoute = createRoute({
+    method: "post",
+    path: "/manage/index",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(indexRoute, async (c) => {
+    const result = await searchHandler.indexPackages();
+    return c.json(result, 200);
+});
+const clearRoute = createRoute({
+    method: "post",
+    path: "/manage/clear",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(clearRoute, async (c) => {
+    const result = await searchHandler.clearIndex();
+    return c.json(result, 200);
+});
+const statsRoute = createRoute({
+    method: "get",
+    path: "/manage/stats",
+    responses: createRouteResponses(managementResponseSchema, {
+        includeErrorResponses: true,
+    }),
+});
+searchRoutes.openapi(statsRoute, async (c) => {
+    const result = await searchHandler.getStats();
+    return c.json(result, 200);
+});

package/dist/domains/search/search-schema.d.ts

@@ -0,0 +1,384 @@
+import { z } from "@hono/zod-openapi";
+export declare const searchQuerySchema: z.ZodObject<{
+    q: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    q: string;
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const searchResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    packageName: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodString;
+    validated: z.ZodBoolean;
+    author: z.ZodString;
+    toolCount: z.ZodNumber;
+    hasTools: z.ZodBoolean;
+    popularity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    name: string;
+    packageName: string;
+    author: string;
+    category: string;
+    validated: boolean;
+    id: string;
+    hasTools: boolean;
+    popularity: number;
+    toolCount: number;
+}, {
+    description: string;
+    name: string;
+    packageName: string;
+    author: string;
+    category: string;
+    validated: boolean;
+    id: string;
+    hasTools: boolean;
+    popularity: number;
+    toolCount: number;
+}>;
+export declare const searchResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        hits: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            packageName: z.ZodString;
+            description: z.ZodString;
+            category: z.ZodString;
+            validated: z.ZodBoolean;
+            author: z.ZodString;
+            toolCount: z.ZodNumber;
+            hasTools: z.ZodBoolean;
+            popularity: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }, {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }>, "many">;
+        query: z.ZodString;
+        processingTimeMs: z.ZodNumber;
+        limit: z.ZodNumber;
+        offset: z.ZodNumber;
+        estimatedTotalHits: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        limit: number;
+        offset: number;
+        hits: {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }[];
+        processingTimeMs: number;
+        estimatedTotalHits: number;
+    }, {
+        query: string;
+        limit: number;
+        offset: number;
+        hits: {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }[];
+        processingTimeMs: number;
+        estimatedTotalHits: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        query: string;
+        limit: number;
+        offset: number;
+        hits: {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }[];
+        processingTimeMs: number;
+        estimatedTotalHits: number;
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        query: string;
+        limit: number;
+        offset: number;
+        hits: {
+            description: string;
+            name: string;
+            packageName: string;
+            author: string;
+            category: string;
+            validated: boolean;
+            id: string;
+            hasTools: boolean;
+            popularity: number;
+            toolCount: number;
+        }[];
+        processingTimeMs: number;
+        estimatedTotalHits: number;
+    } | undefined;
+}>;
+export declare const suggestQuerySchema: z.ZodObject<{
+    q: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    limit?: number | undefined;
+}, {
+    q: string;
+    limit?: number | undefined;
+}>;
+export declare const suggestResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    packageName: z.ZodString;
+    category: z.ZodString;
+    highlighted: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    packageName: string;
+    category: string;
+    highlighted: string;
+}, {
+    name: string;
+    packageName: string;
+    category: string;
+    highlighted: string;
+}>;
+export declare const suggestResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        suggestions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            packageName: z.ZodString;
+            category: z.ZodString;
+            highlighted: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }, {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        suggestions: {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }[];
+    }, {
+        suggestions: {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        suggestions: {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }[];
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        suggestions: {
+            name: string;
+            packageName: string;
+            category: string;
+            highlighted: string;
+        }[];
+    } | undefined;
+}>;
+export declare const facetsResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        authors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        validated: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        validated?: Record<string, number> | undefined;
+        categories?: Record<string, number> | undefined;
+        authors?: Record<string, number> | undefined;
+    }, {
+        validated?: Record<string, number> | undefined;
+        categories?: Record<string, number> | undefined;
+        authors?: Record<string, number> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        validated?: Record<string, number> | undefined;
+        categories?: Record<string, number> | undefined;
+        authors?: Record<string, number> | undefined;
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        validated?: Record<string, number> | undefined;
+        categories?: Record<string, number> | undefined;
+        authors?: Record<string, number> | undefined;
+    } | undefined;
+}>;
+export declare const healthResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        status: z.ZodString;
+        host: z.ZodString;
+        initialized: z.ZodBoolean;
+        indexName: z.ZodString;
+        documentCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    }, {
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    } | undefined;
+}>;
+export declare const managementResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    code: z.ZodNumber;
+    message: z.ZodString;
+} & {
+    data: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        details?: any;
+    }, {
+        message: string;
+        details?: any;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        message: string;
+        details?: any;
+    } | undefined;
+}, {
+    success: boolean;
+    code: number;
+    message: string;
+    data?: {
+        message: string;
+        details?: any;
+    } | undefined;
+}>;

package/dist/domains/search/search-schema.js

@@ -0,0 +1,99 @@
+import { z } from "@hono/zod-openapi";
+import { BaseResponseSchema } from "../../shared/schemas/common-schema";
+export 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",
+    }),
+});
+export 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");
+export 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");
+export 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,
+    }),
+});
+export const suggestResultSchema = z
+    .object({
+    name: z.string(),
+    packageName: z.string(),
+    category: z.string(),
+    highlighted: z.string(),
+})
+    .openapi("SuggestResult");
+export const suggestResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        suggestions: z.array(suggestResultSchema),
+    })
+        .optional(),
+}).openapi("SuggestResponse");
+export 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");
+export 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");
+export const managementResponseSchema = BaseResponseSchema.extend({
+    data: z
+        .object({
+        message: z.string(),
+        details: z.any().optional(),
+    })
+        .optional(),
+}).openapi("ManagementResponse");

package/dist/domains/search/search-so.d.ts

@@ -0,0 +1,55 @@
+import { type Index } from "meilisearch";
+interface SearchOptions {
+    limit?: number;
+    offset?: number;
+    filter?: string | string[];
+    sort?: string[];
+    matchingStrategy?: string;
+}
+/**
+ * Search Service Object
+ * Manages MeiliSearch connection and indexing with singleton pattern
+ */
+export declare class SearchSO {
+    private readonly client;
+    private _index;
+    private readonly host;
+    private readonly indexName;
+    private static instance;
+    private constructor();
+    get index(): Index<Record<string, any>> | null;
+    get isInitialized(): boolean;
+    static getInstance(host?: string, apiKey?: string, indexName?: string): Promise<SearchSO>;
+    private configureIndex;
+    search(query: string, options?: SearchOptions): Promise<{
+        hits: import("meilisearch").Hits<Record<string, any>>;
+        query: string;
+        processingTimeMs: number;
+        limit: number;
+        offset: number;
+        estimatedTotalHits: number;
+    }>;
+    suggest(query: string, limit?: number): Promise<{
+        name: string;
+        packageName: string;
+        category: string;
+        highlighted: string;
+    }[]>;
+    indexPackages(packagesPath: string): Promise<import("meilisearch").IndexStats>;
+    getFacets(): Promise<import("meilisearch").FacetDistribution | undefined>;
+    getStats(): Promise<import("meilisearch").IndexStats>;
+    clearIndex(): Promise<void>;
+    healthCheck(): Promise<{
+        status: string;
+        host: string;
+        initialized: boolean;
+        indexName: string;
+        documentCount: number;
+    }>;
+    private transformPackageForIndex;
+    private createSafeId;
+    private calculatePopularityScore;
+    private extractAuthor;
+    private extractKeywords;
+}
+export {};