@pikku/cli 0.8.2 → 0.9.0

package/dist/src/wirings/http/openapi-spec-generator.js

@@ -0,0 +1,145 @@
+import { pikkuState } from '@pikku/core';
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
+const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
+const getErrorResponseForConstructorName = (constructorName) => {
+    const errors = Array.from(pikkuState('misc', 'errors').entries());
+    const foundError = errors.find(([e]) => e.name === constructorName);
+    if (foundError) {
+        return foundError[1];
+    }
+    return undefined;
+};
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
+    const requiredSchemas = new Set(routesMeta
+        .map(({ inputTypes, pikkuFuncName }) => {
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
+        return [inputTypes?.body, output];
+    })
+        .flat()
+        .filter((schema) => !!schema));
+    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
+        if (requiredSchemas.has(key)) {
+            const convertedSchema = await convertSchema(schema, {
+                convertUnreferencedDefinitions: false,
+                dereference: { circular: 'ignore' },
+            });
+            return [key, convertedSchema];
+        }
+        return;
+    }));
+    return Object.fromEntries(convertedEntries.filter((s) => !!s));
+};
+export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
+    const paths = {};
+    routeMeta.forEach((meta) => {
+        const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
+            return;
+        }
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
+        if (!paths[path]) {
+            paths[path] = {};
+        }
+        const responses = {};
+        docs?.errors?.forEach((error) => {
+            const errorResponse = getErrorResponseForConstructorName(error);
+            if (errorResponse) {
+                responses[errorResponse.status] = {
+                    description: errorResponse.message,
+                };
+            }
+        });
+        const operation = {
+            description: docs?.description ||
+                `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+            tags: docs?.tags || [route.split('/')[1] || 'default'],
+            parameters: [],
+            responses: {
+                ...responses,
+                '200': {
+                    description: 'Successful response',
+                    content: output
+                        ? {
+                            'application/json': {
+                                schema: typeof output === 'string' &&
+                                    ['boolean', 'string', 'number'].includes(output)
+                                    ? { type: output }
+                                    : { $ref: `#/components/schemas/${output}` },
+                            },
+                        }
+                        : undefined,
+                },
+            },
+        };
+        const bodyType = inputTypes?.body;
+        if (bodyType) {
+            operation.requestBody = {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: typeof bodyType === 'string' &&
+                            ['boolean', 'string', 'number'].includes(bodyType)
+                            ? { type: bodyType }
+                            : { $ref: `#/components/schemas/${bodyType}` },
+                    },
+                },
+            };
+        }
+        if (params) {
+            operation.parameters = params.map((param) => ({
+                name: param,
+                in: 'path',
+                required: true,
+                schema: { type: 'string' },
+            }));
+        }
+        if (query) {
+            operation.parameters.push(...query.map((query) => ({
+                name: query,
+                in: 'query',
+                required: false,
+                schema: { type: 'string' },
+            })));
+        }
+        paths[path][method] = operation;
+    });
+    return {
+        openapi: '3.1.0',
+        info: additionalInfo.info,
+        servers: additionalInfo.servers,
+        paths,
+        components: {
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
+            responses: {},
+            parameters: {},
+            examples: {},
+            requestBodies: {},
+            headers: {},
+            securitySchemes: additionalInfo.securitySchemes || {
+                ApiKeyAuth: {
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'x-api-key',
+                },
+                BearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                },
+            },
+        },
+        security: additionalInfo.security || [
+            {
+                ApiKeyAuth: [],
+            },
+            {
+                BearerAuth: [],
+            },
+        ],
+        tags: additionalInfo.tags,
+        externalDocs: additionalInfo.externalDocs,
+        // definitions
+    };
+}

package/dist/src/wirings/http/pikku-command-http-map.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuHTTPMap: PikkuCommand;

package/dist/src/wirings/http/pikku-command-http-map.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js';
+export const pikkuHTTPMap = async (logger, { httpMapDeclarationFile, packageMappings }, { http, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
+        const content = serializeTypedHTTPWiringsMap(httpMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
+        await writeFileInDir(logger, httpMapDeclarationFile, content);
+    });
+};

package/dist/src/wirings/http/pikku-command-http-routes.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuHTTP: PikkuCommand;

package/dist/src/wirings/http/pikku-command-http-routes.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuHTTP = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
+        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+    });
+};

package/dist/src/wirings/http/pikku-command-openapi.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuOpenAPI: PikkuCommand;

package/dist/src/wirings/http/pikku-command-openapi.js

@@ -0,0 +1,20 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { generateSchemas } from '../../schema-generator.js';
+import { generateOpenAPISpec } from './openapi-spec-generator.js';
+import { stringify } from 'yaml';
+export const pikkuOpenAPI = async (logger, { tsconfig, openAPI }, { http, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Creating OpenAPI spec', 'Created OpenAPI spec', [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'], async () => {
+        if (!openAPI?.outputFile) {
+            throw new Error('openAPI is required');
+        }
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
+        const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
+        if (openAPI.outputFile.endsWith('.json')) {
+            await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });
+        }
+        else if (openAPI.outputFile.endsWith('.yaml') ||
+            openAPI.outputFile.endsWith('.yml')) {
+            await writeFileInDir(logger, openAPI.outputFile, stringify(openAPISpec), { ignoreModifyComment: true });
+        }
+    });
+};

package/dist/src/wirings/http/pikku-http-routes.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuHTTP: PikkuCommand;

package/dist/src/wirings/http/pikku-http-routes.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuHTTP = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
+        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+    });
+};

package/dist/src/wirings/http/serialize-fetch-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeFetchWrapper: (routesMapPath: string) => string;

package/dist/src/wirings/http/serialize-fetch-wrapper.js

@@ -0,0 +1,67 @@
+export const serializeFetchWrapper = (routesMapPath) => {
+    return `
+import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+
+export class PikkuFetch extends CorePikkuFetch {
+    public async post<Route extends HTTPWiringsWithMethod<'POST'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'POST'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'POST', data, options);
+    }
+
+    public async get<Route extends HTTPWiringsWithMethod<'GET'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'GET'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'GET', data, options);
+    }
+
+    public async patch<Route extends HTTPWiringsWithMethod<'PATCH'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'PATCH'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'PATCH', data, options);
+    }
+
+    public async head<Route extends HTTPWiringsWithMethod<'HEAD'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'HEAD'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'HEAD'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'HEAD', data, options);
+    }
+
+    public async delete<Route extends HTTPWiringsWithMethod<'DELETE'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'DELETE'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'DELETE', data, options);
+    }
+
+    public async fetch<
+        Route extends keyof HTTPWiringsMap,
+        Method extends keyof HTTPWiringsMap[Route]
+    >(route: Route, method: Method, data: HTTPWiringHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
+        return await super.fetch(route, method as HTTPMethod, data, options);
+    }
+}
+
+export const pikkuFetch = new PikkuFetch();
+`;
+};

package/dist/src/wirings/http/serialize-typed-http-map.d.ts

@@ -0,0 +1,4 @@
+import { HTTPWiringsMeta } from '@pikku/core/http';
+import { MetaInputTypes, TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedHTTPWiringsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes) => string;

package/dist/src/wirings/http/serialize-typed-http-map.js

@@ -0,0 +1,100 @@
+import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
+export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for typescript to be aware of routes and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+${serializedMetaTypes}
+
+interface HTTPWiringHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedHTTPWirings}
+
+export type HTTPWiringHandlerOf<HTTPWiring extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[HTTPWiring]> =
+    HTTPWiringsMap[HTTPWiring][Method] extends { input: infer I; output: infer O }
+        ? HTTPWiringHandler<I, O>
+        : never;
+
+export type HTTPWiringsWithMethod<Method extends string> = {
+  [HTTPWiring in keyof HTTPWiringsMap]: Method extends keyof HTTPWiringsMap[HTTPWiring] ? HTTPWiring : never;
+}[keyof HTTPWiringsMap];
+  `;
+};
+function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect routes
+    const routesObj = {};
+    for (const meta of routesMeta) {
+        const { route, method, pikkuFuncName } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Initialize the route entry if it doesn't exist
+        if (!routesObj[route]) {
+            routesObj[route] = {};
+        }
+        // Store the input and output types separately for RouteHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add method entry
+        routesObj[route][method] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the routes object as a string
+    let routesStr = 'export type HTTPWiringsMap = {\n';
+    for (const [routePath, methods] of Object.entries(routesObj)) {
+        routesStr += `  readonly '${routePath}': {\n`;
+        for (const [method, handler] of Object.entries(methods)) {
+            routesStr += `    readonly ${method.toUpperCase()}: HTTPWiringHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+        }
+        routesStr += '  },\n';
+    }
+    routesStr += '};';
+    return routesStr;
+}
+const generateMetaTypes = (metaTypes, typesMap) => {
+    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
+        const { uniqueName } = typesMap.getTypeMeta(_name);
+        const queryType = query && query.length > 0
+            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
+            : undefined;
+        if (queryType) {
+            result.set(`${uniqueName}Query`, queryType);
+        }
+        const paramsType = params && params.length > 0
+            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
+            : undefined;
+        if (paramsType) {
+            result.set(`${uniqueName}Params`, paramsType);
+        }
+        const bodyType = (body && body.length > 0) || (params && params.length > 0)
+            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
+            : uniqueName;
+        if (bodyType) {
+            result.set(`${uniqueName}Body`, bodyType);
+        }
+        return result;
+    }, new Map());
+    return `
+// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
+${Array.from(nameToTypeMap.entries())
+        .map(([name, type]) => `export type ${name} = ${type} & {}`)
+        .join('\n')}`;
+};

package/dist/src/wirings/mcp/pikku-command-mcp-json.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuMCPJSON: PikkuCommand;

package/dist/src/wirings/mcp/pikku-command-mcp-json.js

@@ -0,0 +1,13 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeMCPJson } from './serialize-mcp-json.js';
+export const pikkuMCPJSON = async (logger, { mcpJsonFile, schemaDirectory }, { mcpEndpoints, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Generating MCP JSON', 'Generated MCP JSON', [mcpEndpoints.files.size === 0 || !mcpJsonFile], async () => {
+        // Generate MCP JSON file
+        if (mcpJsonFile) {
+            const mcpJson = await serializeMCPJson(logger, schemaDirectory, functions.meta, functions.typesMap, mcpEndpoints.resourcesMeta, mcpEndpoints.toolsMeta, mcpEndpoints.promptsMeta);
+            await writeFileInDir(logger, mcpJsonFile, mcpJson, {
+                ignoreModifyComment: true,
+            });
+        }
+    });
+};

package/dist/src/wirings/mcp/pikku-command-mcp.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuMCP: PikkuCommand;

package/dist/src/wirings/mcp/pikku-command-mcp.js

@@ -0,0 +1,54 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+// Helper function to generate arguments from schema
+const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
+    if (!inputSchema)
+        return [];
+    if (['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(inputSchema)) {
+        return [];
+    }
+    const uniqueName = typesMap.getUniqueName(inputSchema);
+    if (!uniqueName)
+        return [];
+    try {
+        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
+        const schemaContent = await readFile(schemaPath, 'utf-8');
+        const schema = JSON.parse(schemaContent);
+        const argumentsArray = [];
+        if (schema && typeof schema === 'object' && schema.properties) {
+            const properties = schema.properties;
+            const required = schema.required || [];
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                argumentsArray.push({
+                    name: propName,
+                    description: propSchema.description || `${propName} parameter`,
+                    required: required.includes(propName),
+                });
+            }
+        }
+        return argumentsArray;
+    }
+    catch (e) {
+        logger.warn(`Could not load schema for type: ${uniqueName}`);
+        return [];
+    }
+};
+export const pikkuMCP = async (logger, { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Finding MCP endpoints', 'Found MCP endpoints', [mcpEndpoints.files.size === 0], async () => {
+        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
+        // Populate arguments for prompts meta before serializing
+        const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
+        for (const promptMeta of Object.values(promptsMetaWithArguments)) {
+            const functionMeta = functions.meta[promptMeta.pikkuFuncName];
+            if (functionMeta) {
+                const inputType = functionMeta.inputs?.[0];
+                promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
+            }
+        }
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
+pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
+pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
+pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`);
+    });
+};

package/dist/src/wirings/mcp/serialize-mcp-json.d.ts

@@ -0,0 +1,5 @@
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core';
+import { FunctionsMeta } from '@pikku/core';
+import { TypesMap } from '@pikku/inspector';
+import { CLILogger } from '../../utils.js';
+export declare const serializeMCPJson: (logger: CLILogger, schemaDirectory: string, functionsMeta: FunctionsMeta, typesMap: TypesMap, mcpResourceMeta: MCPResourceMeta, mcpToolMeta: MCPToolMeta, mcpPromptMeta: MCPPromptMeta) => Promise<string>;

package/dist/src/wirings/mcp/serialize-mcp-json.js

@@ -0,0 +1,101 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+export const serializeMCPJson = async (logger, schemaDirectory, functionsMeta, typesMap, mcpResourceMeta, mcpToolMeta, mcpPromptMeta) => {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    // Helper function to load schema from file
+    const loadSchema = async (typeName) => {
+        if (!typeName ||
+            ['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(typeName)) {
+            return undefined;
+        }
+        const uniqueName = typesMap.getUniqueName(typeName);
+        if (!uniqueName) {
+            return undefined;
+        }
+        try {
+            const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
+            const schemaContent = await readFile(schemaPath, 'utf-8');
+            return JSON.parse(schemaContent);
+        }
+        catch (e) {
+            logger.warn(`Could not load schema for type: ${uniqueName}`);
+            return undefined;
+        }
+    };
+    // Process MCP resources
+    for (const [name, endpointMeta] of Object.entries(mcpResourceMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping resource ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = await loadSchema(inputType);
+        const returns = await loadSchema(outputType);
+        const endpoint = {
+            uri: name,
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        };
+        resources.push(endpoint);
+    }
+    // Process MCP tools
+    for (const [name, endpointMeta] of Object.entries(mcpToolMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping tool ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = await loadSchema(inputType);
+        const returns = await loadSchema(outputType);
+        const endpoint = {
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        };
+        tools.push(endpoint);
+    }
+    // Process MCP prompts
+    for (const [name, endpointMeta] of Object.entries(mcpPromptMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncName];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncName} not found in functionsMeta. Skipping prompt ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        // TODO: this needs to be a json schema type, not any
+        const inputSchema = await loadSchema(inputType);
+        // Generate arguments from input schema
+        const argumentsArray = [];
+        if (inputSchema &&
+            typeof inputSchema === 'object' &&
+            inputSchema.properties) {
+            const properties = inputSchema.properties;
+            const required = inputSchema.required || [];
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                argumentsArray.push({
+                    name: propName,
+                    description: propSchema.description || `${propName} parameter`,
+                    required: required.includes(propName),
+                });
+            }
+        }
+        const prompt = {
+            name,
+            description: endpointMeta.description,
+            arguments: argumentsArray,
+        };
+        prompts.push(prompt);
+    }
+    return JSON.stringify({ tools, resources, prompts }, null, 2);
+};

package/dist/src/wirings/queue/pikku-command-queue-map.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuQueueMap: PikkuCommand;

package/dist/src/wirings/queue/pikku-command-queue-map.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeQueueMap } from './serialize-queue-map.js';
+export const pikkuQueueMap = async (logger, { queueMapDeclarationFile, packageMappings }, { queueWorkers, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Creating Queue map', 'Created Queue map', [queueWorkers.files.size === 0], async () => {
+        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        await writeFileInDir(logger, queueMapDeclarationFile, content);
+    });
+};

package/dist/src/wirings/queue/pikku-command-queue-service.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommandWithoutState } from '../../types.js';
+export declare const pikkuQueueService: PikkuCommandWithoutState;

package/dist/src/wirings/queue/pikku-command-queue-service.js

@@ -0,0 +1,15 @@
+import { serializeQueueWrapper } from './serialize-queue-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuQueueService = async (logger, { queueWiringsFile, queueMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating queue service wrapper', 'Generated queue service wrapper', [
+        queueWiringsFile === undefined,
+        "queueWiringsFile isn't set in the pikku config",
+    ], async () => {
+        if (!queueWiringsFile) {
+            throw new Error("queueWiringsFile is isn't set in the pikku config");
+        }
+        const queueMapDeclarationPath = getFileImportRelativePath(queueWiringsFile, queueMapDeclarationFile, packageMappings);
+        const content = [serializeQueueWrapper(queueMapDeclarationPath)];
+        await writeFileInDir(logger, queueWiringsFile, content.join('\n'));
+    });
+};

package/dist/src/wirings/queue/pikku-command-queue.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuQueue: PikkuCommand;

package/dist/src/wirings/queue/pikku-command-queue.js

@@ -0,0 +1,10 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+import { serializeQueueMeta } from './serialize-queue-meta.js';
+export const pikkuQueue = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding queues', 'Found queue', [visitState.queueWorkers.files.size === 0], async () => {
+        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = cliConfig;
+        const { queueWorkers } = visitState;
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
+    });
+};

package/dist/src/wirings/queue/pikku-queue-map.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuQueueMap: PikkuCommand;

package/dist/src/wirings/queue/pikku-queue-map.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeQueueMap } from './serialize-queue-map.js';
+export const pikkuQueueMap = async (logger, { queueMapDeclarationFile, packageMappings }, { queueWorkers, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Creating Queue map', 'Created Queue map', [queueWorkers.files.size === 0], async () => {
+        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        await writeFileInDir(logger, queueMapDeclarationFile, content);
+    });
+};

package/dist/src/wirings/queue/pikku-queue.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuQueue: PikkuCommand;