@pikku/cli 0.7.7 → 0.8.1

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-command-services.d.ts

@@ -0,0 +1,3 @@
+import { PikkuCommand } from '../../types.js';
+export declare const serializeServicesMap: (functionsMetaData: Record<string, any>, middlewareServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const pikkuServices: PikkuCommand;

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

@@ -0,0 +1,73 @@
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
+    // Extract all unique services from all functions
+    const usedServices = new Set();
+    // Internal services that are created internally and not via the create service script
+    const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession']);
+    for (const funcMeta of Object.values(functionsMetaData)) {
+        if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
+            funcMeta.services.services.forEach((service) => {
+                // Only include services that are not internal
+                if (!internalServices.has(service)) {
+                    usedServices.add(service);
+                }
+            });
+        }
+    }
+    // Add middleware services that might not be detected from function inspection
+    middlewareServices.forEach((service) => {
+        if (!internalServices.has(service)) {
+            usedServices.add(service);
+        }
+    });
+    // Create a map of services with true for all needed services
+    const servicesMap = Object.fromEntries(Array.from(usedServices)
+        .sort()
+        .map((service) => [service, true]));
+    // Generate the TypeScript code
+    const serviceKeys = Object.keys(servicesMap).sort();
+    // Services that are always required internally by the framework
+    const defaultServices = ['config', 'logger', 'variables', 'schema'];
+    // Combine default services with detected services
+    const allRequiredServices = [
+        ...new Set([...defaultServices, ...serviceKeys]),
+    ].sort();
+    // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
+    // This will be resolved at compile time based on what's actually in the SingletonServices interface
+    // We don't need to hardcode which services are singletons beyond the core framework ones
+    const code = [
+        '/**',
+        ' * This file was generated by the @pikku/cli',
+        ' */',
+        '',
+        servicesImport,
+        sessionServicesImport,
+        "import type { PikkuInteraction } from '@pikku/core'",
+        '',
+        'export const singletonServices = {',
+        ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+        '} as const',
+        '',
+        '// Singleton services (created once at startup)',
+        '// Only includes services that are both required and available in SingletonServices',
+        `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+        '',
+        '// Session services (created per request, can access singleton services)',
+        '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
+        `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+        '',
+    ].join('\n');
+    return code;
+};
+export const pikkuServices = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [visitState.functions.files.size === 0], async () => {
+        const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`;
+        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`;
+        const servicesCode = serializeServicesMap(visitState.functions.meta, cliConfig.middlewareServices, servicesImport, sessionServicesImport);
+        await writeFileInDir(logger, cliConfig.servicesFile, servicesCode);
+    });
+};

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-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.d.ts → events/http/serialize-typed-http-map.d.ts}

@@ -2,4 +2,3 @@ import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
 export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
-export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

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

@@ -1,4 +1,5 @@
-import { serializeImportMap } from './utils/serialize-import-map.js';
+import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
 export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
@@ -30,20 +31,6 @@ export type RoutesWithMethod<Method extends string> = {
 }[keyof RoutesMap];
   `;
 };
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
-        references.forEach((name) => {
-            const originalName = typesMap.getTypeMeta(name).originalName;
-            requiredTypes.add(originalName);
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}
 function generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};

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;