@pikku/cli 0.9.0 → 0.9.2

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

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

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

@@ -1,8 +0,0 @@
-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/events/http/pikku-command-http-routes.d.ts

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

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

@@ -1,9 +0,0 @@
-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/events/http/pikku-command-nextjs.d.ts

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

package/dist/src/events/http/pikku-command-nextjs.js

@@ -1,36 +0,0 @@
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../../runtimes/nextjs/serialize-nextjs-backend-wrapper.js';
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../../runtimes/nextjs/serialize-nextjs-http-wrapper.js';
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
-        nextBackendFile === undefined && nextHTTPFile === undefined,
-        'nextjs outfile is not defined',
-    ], async () => {
-        if (!nextBackendFile && !nextHTTPFile) {
-            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
-        }
-        if (nextHTTPFile && !fetchFile) {
-            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
-        }
-        if (nextBackendFile) {
-            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, nextBackendFile, options, {
-                config: true,
-                singletonServicesFactory: true,
-                sessionServicesFactory: true,
-            });
-            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
-            const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
-            await writeFileInDir(logger, nextBackendFile, content);
-        }
-        if (nextHTTPFile && fetchFile) {
-            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
-            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
-            await writeFileInDir(logger, nextHTTPFile, content);
-        }
-    });
-};

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

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

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

@@ -1,20 +0,0 @@
-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/events/http/pikku-http-routes.d.ts

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

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

@@ -1,9 +0,0 @@
-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/events/http/serialize-fetch-wrapper.d.ts

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

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

@@ -1,67 +0,0 @@
-export const serializeFetchWrapper = (routesMapPath) => {
-    return `
-import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
-
-export class PikkuFetch extends CorePikkuFetch {
-    public async post<Route extends RoutesWithMethod<'POST'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'POST'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'POST', data, options);
-    }
-
-    public async get<Route extends RoutesWithMethod<'GET'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'GET'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'GET', data, options);
-    }
-
-    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'PATCH'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'PATCH', data, options);
-    }
-
-    public async head<Route extends RoutesWithMethod<'HEAD'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'HEAD'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'HEAD', data, options);
-    }
-
-    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'DELETE'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'DELETE', data, options);
-    }
-
-    public async fetch<
-        Route extends keyof RoutesMap,
-        Method extends keyof RoutesMap[Route]
-    >(route: Route, method: Method, data: RouteHandlerOf<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/events/http/serialize-typed-http-map.d.ts

@@ -1,4 +0,0 @@
-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/events/http/serialize-typed-http-map.js

@@ -1,100 +0,0 @@
-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 RoutesMap = {\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()}: RouteHandler<${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/events/mcp/pikku-command-mcp-json.d.ts

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

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

@@ -1,13 +0,0 @@
-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/events/mcp/pikku-command-mcp.d.ts

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

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

@@ -1,54 +0,0 @@
-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/events/mcp/serialize-mcp-json.d.ts

@@ -1,5 +0,0 @@
-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/events/mcp/serialize-mcp-json.js

@@ -1,101 +0,0 @@
-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/events/queue/pikku-command-queue-map.d.ts

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

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

@@ -1,8 +0,0 @@
-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/events/queue/pikku-command-queue-service.d.ts

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

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

@@ -1,12 +0,0 @@
-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/events/queue/pikku-command-queue.d.ts

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

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

@@ -1,10 +0,0 @@
-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/events/queue/pikku-queue-map.d.ts

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

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

@@ -1,8 +0,0 @@
-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/events/queue/pikku-queue.d.ts

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

package/dist/src/events/queue/pikku-queue.js

@@ -1,10 +0,0 @@
-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/events/queue/serialize-queue-map.d.ts

@@ -1,4 +0,0 @@
-import type { queueWorkersMeta } from '@pikku/core/queue';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: queueWorkersMeta) => string;

package/dist/src/events/queue/serialize-queue-map.js

@@ -1,77 +0,0 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
-export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
-    const requiredTypes = new Set();
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedQueues = generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-
-import type { QueueJob } from '@pikku/core/queue'
-
-interface QueueHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedQueues}
-
-type QueueAdd = <Name extends keyof QueueMap>(
-  name: Name,
-  data: QueueMap[Name]['input'],
-  options?: {
-    priority?: number
-    delay?: number
-    attempts?: number
-    removeOnComplete?: number
-    removeOnFail?: number
-    jobId?: string
-  }
-) => Promise<string>
-
-type QueueGetJob = <Name extends keyof QueueMap>(
-  name: Name,
-  jobId: string
-) => Promise<QueueJob<QueueMap[Name]['input'], QueueMap[Name]['output']> | null>
-
-export type TypedPikkuQueue = {
-  add: QueueAdd;
-  getJob: QueueGetJob;
-}
-  `;
-};
-function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect queues
-    const queuesObj = {};
-    // Iterate through Queue metadata
-    for (const [queueName, { pikkuFuncName }] of Object.entries(queueWorkersMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${queueName} not found in functionsMeta. Please check your configuration.`);
-        }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for QueueHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add Queue entry
-        queuesObj[queueName] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the Queues object as a string
-    let queuesStr = 'export type QueueMap = {\n';
-    for (const [queueName, handler] of Object.entries(queuesObj)) {
-        queuesStr += `  readonly '${queueName}': QueueHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-    }
-    queuesStr += '};\n';
-    return queuesStr;
-}