@pikku/cli 0.9.14 → 0.9.16-next.0

package/src/functions/wirings/functions/serialize-function-types.ts

@@ -0,0 +1,303 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export const serializeFunctionTypes = (
+  userSessionTypeImport: string,
+  userSessionTypeName: string,
+  singletonServicesTypeImport: string,
+  singletonServicesTypeName: string,
+  sessionServicesTypeImport: string,
+  sessionServicesTypeName: string,
+  rpcMapTypeImport: string
+) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * Core function, middleware, and permission types for all wirings
+ */
+
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
+import { PikkuChannel, PikkuMCP } from '@pikku/core'
+
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+${sessionServicesTypeImport}
+${rpcMapTypeImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+
+/**
+ * Type-safe API permission definition that integrates with your application's session type.
+ * Use this to define authorization logic for your API endpoints.
+ *
+ * @template In - The input type that the permission check will receive
+ * @template RequiredServices - The services required for this permission check
+ */
+export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
+
+/**
+ * Type-safe middleware definition that can access your application's services and session.
+ * Use this to define reusable middleware that can be applied to multiple wirings.
+ *
+ * @template RequiredServices - The services required for this middleware
+ */
+export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+
+/**
+ * Factory function for creating permissions with tree-shaking support.
+ * This enables the bundler to detect which services your permission actually uses.
+ *
+ * @example
+ * \`\`\`typescript
+ * const permission = pikkuPermission(({ logger }, data, session) => {
+ *   return session?.isAdmin || false
+ * })
+ * \`\`\`
+ */
+export const pikkuPermission = <In>(func: PikkuPermission<In>) => {
+  return func
+}
+
+/**
+ * Factory function for creating middleware with tree-shaking support.
+ * This enables the bundler to detect which services your middleware actually uses.
+ *
+ * @example
+ * \`\`\`typescript
+ * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ *   logger.info('Middleware executed')
+ *   await next()
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddleware = (func: PikkuMiddleware) => {
+  return func
+}
+
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddlewareFactory = <In = any>(
+  factory: (input: In) => PikkuMiddleware
+): ((input: In) => PikkuMiddleware) => {
+  return factory
+}
+
+/**
+ * A sessionless API function that doesn't require user authentication.
+ * Use this for public endpoints, health checks, or operations that don't need user context.
+ *
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
+export type PikkuFunctionSessionless<
+  In = unknown,
+  Out = never,
+  ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
+    [ChannelData] extends [null]
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
+  )
+> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
+
+/**
+ * A session-aware API function that requires user authentication.
+ * Use this for protected endpoints that need access to user session data.
+ *
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
+export type PikkuFunction<
+  In = unknown,
+  Out = never,
+  ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
+  RequiredServices extends Services = Omit<Services, 'rpc'> &
+    { rpc: TypedPikkuRPC } & (
+    [ChannelData] extends [null]
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
+  )
+> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
+
+/**
+ * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
+ * This type wraps CorePikkuFunctionConfig with the user's custom types.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
+ */
+export type PikkuFunctionConfig<
+  In = unknown,
+  Out = unknown,
+  PikkuFunc extends PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out> = PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out>
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * Creates a Pikku function that can be either session-aware or sessionless.
+ * This is the main function wrapper for creating API endpoints.
+ *
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
+ *   func: async ({db, logger}, input) => {
+ *     logger.info('Creating user', input.name)
+ *     const user = await db.users.create(input)
+ *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
+ *   },
+ *   auth: true
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunction<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a sessionless Pikku function that doesn't require user authentication.
+ * Use this for public endpoints, webhooks, or background tasks.
+ *
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
+ *   func: async ({logger}) => {
+ *     logger.info('Health check requested')
+ *     return {status: 'healthy', timestamp: new Date().toISOString()}
+ *   },
+ *   name: 'healthCheck'
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that takes no input and returns no output.
+ * Useful for health checks, triggers, or cleanup operations.
+ *
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
+ *     logger.info('Starting cleanup of temporary files')
+ *     await fileSystem.deleteDirectory('/tmp/uploads')
+ *     logger.info('Cleanup completed')
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuVoidFunc = (
+  func:
+    | PikkuFunctionSessionless<void, void>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the middleware should apply to.
+ * @param middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws Error if middleware for the tag already exists.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * \`\`\`
+ */
+export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
+  addMiddlewareCore(tag, middleware as any)
+}
+
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the permissions should apply to.
+ * @param permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws Error if permissions for the tag already exist.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * \`\`\`
+ */
+export const addPermission = <In = unknown>(tag: string, permissions: PikkuPermission<In>[]) => {
+  addPermissionCore(tag, permissions as any)
+}
+`
+}

package/src/functions/wirings/functions/serialize-pikku-types-hub.ts

@@ -0,0 +1,39 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export const serializePikkuTypesHub = (
+  functionTypesImportPath: string,
+  httpTypesImportPath: string,
+  channelTypesImportPath: string,
+  schedulerTypesImportPath: string,
+  queueTypesImportPath: string,
+  mcpTypesImportPath: string,
+  cliTypesImportPath: string
+) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * Main type export hub - re-exports all wiring-specific types
+ */
+
+// Core function, middleware, and permission types
+export * from '${functionTypesImportPath}'
+
+// HTTP wiring types
+export * from '${httpTypesImportPath}'
+
+// Channel wiring types
+export * from '${channelTypesImportPath}'
+
+// Scheduler wiring types
+export * from '${schedulerTypesImportPath}'
+
+// Queue wiring types
+export * from '${queueTypesImportPath}'
+
+// MCP wiring types
+export * from '${mcpTypesImportPath}'
+
+// CLI wiring types
+export * from '${cliTypesImportPath}'
+`
+}

package/src/{wirings → functions/wirings}/http/openapi-spec-generator.ts

@@ -1,5 +1,6 @@
 import { FunctionsMeta, HTTPWiringsMeta, pikkuState } from '@pikku/core'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
+import { CLILogger } from '../../../services/cli-logger.service.js'
 const convertSchema =
   'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
 
@@ -108,6 +109,7 @@ const convertSchemasToBodyPayloads = async (
 }
 
 export async function generateOpenAPISpec(
+  logger: CLILogger,
   functionsMeta: FunctionsMeta,
   httpMeta: HTTPWiringsMeta,
   schemas: Record<string, any>,
@@ -121,7 +123,7 @@ export async function generateOpenAPISpec(
         meta
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
-        console.error(
+        logger.error(
           `• No function metadata found for '${pikkuFuncName}' in route '${route}'.`
         )
         continue

package/src/functions/wirings/http/pikku-command-http-map.ts

@@ -0,0 +1,32 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js'
+
+export const pikkuHTTPMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { http, functions } = await getInspectorState()
+    const { httpMapDeclarationFile, packageMappings } = config
+
+    const content = serializeTypedHTTPWiringsMap(
+      httpMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      http.meta,
+      http.metaInputTypes
+    )
+    await writeFileInDir(logger, httpMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating HTTP map',
+      commandEnd: 'Created HTTP map',
+      skipCondition: async ({ getInspectorState }) => {
+        const { http } = await getInspectorState()
+        return http.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/functions/wirings/http/pikku-command-http-routes.ts

@@ -0,0 +1,41 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    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)})`
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding HTTP routes',
+      commandEnd: 'Found HTTP routes',
+      skipCondition: async ({ getInspectorState }) => {
+        const visitState = await getInspectorState()
+        return visitState.http.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/functions/wirings/http/pikku-command-http-types.ts

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeHTTPTypes } from './serialize-http-types.js'
+
+export const pikkuHTTPTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { httpTypesFile, functionTypesFile, packageMappings } = config
+
+    const functionTypesImportPath = getFileImportRelativePath(
+      httpTypesFile,
+      functionTypesFile,
+      packageMappings
+    )
+    const content = serializeHTTPTypes(functionTypesImportPath)
+    await writeFileInDir(logger, httpTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating HTTP types',
+      commandEnd: 'Created HTTP types',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/functions/wirings/http/pikku-command-openapi.ts

@@ -0,0 +1,57 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { generateSchemas } from '../../../utils/schema-generator.js'
+import { generateOpenAPISpec } from './openapi-spec-generator.js'
+import { stringify } from 'yaml'
+
+export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { http, functions } = await getInspectorState()
+    const { tsconfig, openAPI, schemasFromTypes } = config
+
+    if (!openAPI?.outputFile) {
+      throw new Error('openAPI is required')
+    }
+
+    const schemas = await generateSchemas(
+      logger,
+      tsconfig,
+      functions.typesMap,
+      functions.meta,
+      http.meta,
+      schemasFromTypes
+    )
+    const openAPISpec = await generateOpenAPISpec(
+      logger,
+      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,
+      })
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating OpenAPI spec',
+      commandEnd: 'Created OpenAPI spec',
+      skipCondition: ({ config }) => config.openAPI?.outputFile === undefined,
+      skipMessage: 'openAPI outfile is not defined',
+    }),
+  ],
+})

package/src/functions/wirings/http/pikku-http-routes.ts

@@ -0,0 +1,40 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    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)})`
+    )
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding HTTP routes',
+      commandEnd: 'Found HTTP routes',
+      skipCondition: async ({ getInspectorState }) => {
+        const visitState = await getInspectorState()
+        return visitState.http.files.size === 0
+      },
+      skipMessage: 'none found',
+    }),
+  ],
+})

package/src/functions/wirings/http/serialize-http-types.ts

@@ -0,0 +1,64 @@
+/**
+ * Generates type definitions for HTTP wirings
+ */
+export const serializeHTTPTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * This file was generated by the @pikku/cli
+ * HTTP-specific type definitions for tree-shaking optimization
+ */
+
+import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
+
+/**
+ * Type definition for HTTP API wirings with type-safe path parameters.
+ * Supports both authenticated and unauthenticated functions.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ */
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out>, PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * Registers an HTTP wiring with the Pikku framework.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
+ */
+export const wireHTTP = <In, Out, Route extends string>(
+  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
+) => {
+  wireHTTPCore(httpWiring as any)
+}
+
+/**
+ * Registers HTTP middleware either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with middleware, the middleware
+ * is applied only to that route. Otherwise, if an array is provided, it is treated
+ * as global middleware (applied to all routes).
+ *
+ * @param routeOrMiddleware - Either a global middleware array or a route pattern string
+ * @param middleware - The middleware array to apply when a route pattern is specified
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP middleware
+ * addHTTPMiddleware([authMiddleware, loggingMiddleware])
+ *
+ * // Add route-specific middleware
+ * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
+ * \`\`\`
+ */
+export const addHTTPMiddleware = (
+  routeOrMiddleware: PikkuMiddleware[] | string,
+  middleware?: PikkuMiddleware[]
+) => {
+  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
+}
+`
+}

package/src/{wirings → functions/wirings}/http/serialize-typed-http-map.ts

@@ -1,8 +1,8 @@
 import { HTTPWiringsMeta } from '@pikku/core/http'
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 
 export const serializeTypedHTTPWiringsMap = (
   relativeToPath: string,

package/src/functions/wirings/mcp/pikku-command-mcp-json.ts

@@ -0,0 +1,38 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeMCPJson } from './serialize-mcp-json.js'
+
+export const pikkuMCPJSON: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { mcpEndpoints, functions } = await getInspectorState()
+    const { mcpJsonFile, schemaDirectory } = config
+
+    // 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,
+      })
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating MCP JSON',
+      commandEnd: 'Generated MCP JSON',
+      skipCondition: async ({ getInspectorState, config }) => {
+        const { mcpEndpoints } = await getInspectorState()
+        return mcpEndpoints.files.size === 0 || !config.mcpJsonFile
+      },
+      skipMessage: 'none found or mcpJsonFile not set',
+    }),
+  ],
+})