@pikku/cli 0.7.7 → 0.8.0

package/dist/src/events/fetch/index.js

@@ -0,0 +1,12 @@
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuFetch = async (logger, { fetchFile, httpRoutesMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, "fetchFile isn't set in the pikku config"], async () => {
+        if (!fetchFile) {
+            throw new Error("fetchFile is isn't set in the pikku config");
+        }
+        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpRoutesMapDeclarationFile, packageMappings);
+        const content = [serializeFetchWrapper(routesMapDeclarationPath)];
+        await writeFileInDir(logger, fetchFile, content.join('\n'));
+    });
+};

package/dist/src/events/functions/pikku-command-function-types.d.ts

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

package/dist/src/events/functions/pikku-command-function-types.js

@@ -0,0 +1,13 @@
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+import { serializePikkuTypes } from '../../serialize-pikku-types.js';
+export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
+    return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
+        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
+        await writeFileInDir(logger, typesFile, content);
+    });
+};

package/dist/src/events/functions/pikku-command-functions.d.ts

@@ -0,0 +1,6 @@
+import { PikkuCommand } from '../../types.js';
+export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings?: Record<string, string>) => string;
+export declare const pikkuFunctions: PikkuCommand;

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

@@ -0,0 +1,35 @@
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
+    const serializedImports = [
+        `/* Import and register RPCs */`,
+        `import { addFunction } from '@pikku/core'`,
+    ];
+    const serializedRegistrations = [];
+    // Sort by function name for consistent output
+    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [name, { path, exportedName }] of sortedEntries) {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        // For directly exported functions, we can just import and register them
+        if (name === exportedName) {
+            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
+        }
+        // For renamed functions, we need to import and alias them
+        else {
+            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', ${name})`);
+        }
+    }
+    // Add a blank line between imports and registrations
+    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+        serializedImports.push('');
+    }
+    // Combine the imports and registrations
+    return [...serializedImports, ...serializedRegistrations].join('\n');
+};
+export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
+    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
+        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+    });
+};

package/dist/src/events/functions/pikku-function-types.d.ts

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

package/dist/{bin → src/events/functions}/pikku-function-types.js

@@ -1,13 +1,13 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
-import { serializePikkuTypes } from '../src/serialize-pikku-types.js';
-export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile, }, options, visitState) => {
-    await logCommandInfoAndTime('Creating api types', 'Created api types', [false], async () => {
-        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, {
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+import { serializePikkuTypes } from '../../serialize-pikku-types.js';
+export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
+    return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
+        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
             userSessionType: true,
             sessionServiceType: true,
             singletonServicesType: true,
         });
         const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
-        await writeFileInDir(typesFile, content);
+        await writeFileInDir(logger, typesFile, content);
     });
 };

package/dist/src/events/functions/pikku-functions.d.ts

@@ -0,0 +1,6 @@
+import { PikkuCommand } from '../../types.js';
+export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings?: Record<string, string>) => string;
+export declare const pikkuFunctions: PikkuCommand;

package/dist/{bin → src/events/functions}/pikku-functions.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
 export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
     const serializedImports = [
         `/* Import and register RPCs */`,
@@ -27,9 +27,9 @@ export const serializeFunctionImports = (outputPath, functionsMap, packageMappin
     // Combine the imports and registrations
     return [...serializedImports, ...serializedRegistrations].join('\n');
 };
-export const pikkuFunctions = async ({ functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
-    return await logCommandInfoAndTime('Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
-        await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
+    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
+        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
     });
 };

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

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

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

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

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

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

package/dist/src/events/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 { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        await writeFileInDir(logger, httpRoutesFile, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+    });
+};

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

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

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

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

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

package/dist/src/events/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/events/http/pikku-http-routes.d.ts

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

package/dist/src/events/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 { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
+        const { http } = visitState;
+        await writeFileInDir(logger, httpRoutesFile, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+    });
+};

package/dist/src/{serialize-typed-http-map.js → events/http/serialize-typed-http-map.js}

@@ -1,4 +1,4 @@
-import { serializeImportMap } from './utils/serialize-import-map.js';
+import { serializeImportMap } from '../../serialize-import-map.js';
 export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);

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

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

package/dist/src/events/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/events/mcp/pikku-command-mcp.d.ts

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

package/dist/src/events/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, { mcpEndpointsFile, mcpEndpointsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Finding MCP endpoints', 'Found MCP endpoints', [mcpEndpoints.files.size === 0], async () => {
+        await writeFileInDir(logger, mcpEndpointsFile, serializeFileImports('addMCPResource or addMCPTool', mcpEndpointsFile, 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, mcpEndpointsMetaFile, `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

@@ -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/events/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/events/queue/pikku-command-queue-map.d.ts

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

package/dist/src/events/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/events/queue/pikku-command-queue-service.d.ts

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

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

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

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

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

package/dist/src/events/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 { queueWorkersFile, queueWorkersMetaFile, packageMappings } = cliConfig;
+        const { queueWorkers } = visitState;
+        await writeFileInDir(logger, queueWorkersMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersFile, serializeFileImports('addQueueWorkers', queueWorkersFile, queueWorkers.files, packageMappings));
+    });
+};

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

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

package/dist/src/events/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/events/queue/pikku-queue.d.ts

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

package/dist/src/events/queue/pikku-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 { queueWorkersFile, queueWorkersMetaFile, packageMappings } = cliConfig;
+        const { queueWorkers } = visitState;
+        await writeFileInDir(logger, queueWorkersMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersFile, serializeFileImports('addQueueWorkers', queueWorkersFile, queueWorkers.files, packageMappings));
+    });
+};

package/dist/src/events/queue/serialize-queue-map.d.ts

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

@@ -0,0 +1,77 @@
+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;
+}

package/dist/src/events/queue/serialize-queue-meta.d.ts

@@ -0,0 +1,2 @@
+import { queueWorkersMeta } from '@pikku/core';
+export declare const serializeQueueMeta: (queueWorkersMeta: queueWorkersMeta) => string;

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

@@ -0,0 +1,6 @@
+export const serializeQueueMeta = (queueWorkersMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('queue', 'meta', ${JSON.stringify(queueWorkersMeta, null, 2)})`);
+    return serializedOutput.join('\n');
+};

package/dist/src/events/queue/serialize-queue-wrapper.d.ts

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