@pikku/cli 0.9.16-next.0 → 0.10.1

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

@@ -3,23 +3,18 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
-    // Extract all unique services from all functions
-    const usedServices = new Set();
+export const serializeServicesMap = (requiredServices, forceRequiredServices = [], servicesImport, sessionServicesImport) => {
+    // Use pre-aggregated services from inspector state
+    // This includes services from:
+    // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
+    // - Middleware used by wired functions
+    // - Permissions used by wired functions
+    // - Session factories
+    const usedServices = new Set(requiredServices);
     // 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) => {
+    // Add force-required services that might not be detected from function inspection
+    forceRequiredServices.forEach((service) => {
         if (!internalServices.has(service)) {
             usedServices.add(service);
         }
@@ -40,10 +35,6 @@ export const serializeServicesMap = (functionsMetaData, middlewareServices = [],
     // 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'",
@@ -77,14 +68,13 @@ export const pikkuServices = pikkuSessionlessFunc({
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
         const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.functions.meta, config.middlewareServices, servicesImport, sessionServicesImport);
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [
         logCommandInfoAndTime({
             commandStart: 'Generating Pikku services map',
             commandEnd: 'Generated Pikku services map',
-            skipMessage: '',
         }),
     ],
 });

package/dist/src/functions/wirings/functions/pikku-function-types.js

@@ -13,8 +13,6 @@ export const pikkuFunctionTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating api types hub',
             commandEnd: 'Created api types hub',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

package/dist/src/functions/wirings/functions/schemas.js

@@ -15,8 +15,6 @@ export const pikkuSchemas = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Generating schemas',
             commandEnd: 'Generated schemas',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -1,4 +1,4 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string) => string;
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string) => string;

package/dist/src/functions/wirings/functions/serialize-function-types.js

@@ -1,24 +1,27 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport) => {
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport) => {
     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 { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
-import { PikkuChannel, PikkuMCP } from '@pikku/core'
+import { PikkuChannel } from '@pikku/core/channel'
+import { PikkuMCP } from '@pikku/core/mcp'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
+${configTypeImport}
 ${rpcMapTypeImport}
+${requiredServicesTypeImport}
 
 ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
 ${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
 ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
 /**
  * Type-safe API permission definition that integrates with your application's session type.
@@ -37,35 +40,84 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  */
 export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
 
+/**
+ * Configuration object for creating a permission with metadata
+ */
+export type PikkuPermissionConfig<In = unknown, RequiredServices extends Services = Services> = {
+  /** The permission function */
+  func: PikkuPermission<In, RequiredServices>
+  /** Optional human-readable name for the permission */
+  name?: string
+  /** Optional description of what the permission checks */
+  description?: string
+}
+
 /**
  * Factory function for creating permissions with tree-shaking support.
- * This enables the bundler to detect which services your permission actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * \`\`\`typescript
+ * // Direct function syntax
  * const permission = pikkuPermission(({ logger }, data, session) => {
- *   return session?.isAdmin || false
+ *   return session?.role === 'admin'
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * const adminPermission = pikkuPermission({
+ *   name: 'Admin Permission',
+ *   description: 'Checks if user has admin role',
+ *   func: async ({ logger }, data, session) => {
+ *     return session?.role === 'admin'
+ *   }
  * })
  * \`\`\`
  */
-export const pikkuPermission = <In>(func: PikkuPermission<In>) => {
-  return func
+export const pikkuPermission = <In>(
+  permission: PikkuPermission<In> | PikkuPermissionConfig<In>
+): PikkuPermission<In> => {
+  return typeof permission === 'function' ? permission : permission.func
+}
+
+/**
+ * Configuration object for creating middleware with metadata
+ */
+export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = SingletonServices> = {
+  /** The middleware function */
+  func: PikkuMiddleware<RequiredServices>
+  /** Optional human-readable name for the middleware */
+  name?: string
+  /** Optional description of what the middleware does */
+  description?: string
 }
 
 /**
  * Factory function for creating middleware with tree-shaking support.
- * This enables the bundler to detect which services your middleware actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * \`\`\`typescript
+ * // Direct function syntax
  * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
  *   logger.info('Middleware executed')
  *   await next()
  * })
+ *
+ * // Configuration object syntax with metadata
+ * const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs all incoming requests',
+ *   func: async ({ logger }, interactions, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
  * \`\`\`
  */
-export const pikkuMiddleware = (func: PikkuMiddleware) => {
-  return func
+export const pikkuMiddleware = <RequiredServices extends SingletonServices = SingletonServices>(
+  middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>
+): PikkuMiddleware<RequiredServices> => {
+  return typeof middleware === 'function' ? middleware : middleware.func
 }
 
 /**
@@ -91,6 +143,31 @@ export const pikkuMiddlewareFactory = <In = any>(
   return factory
 }
 
+/**
+ * Factory function for creating permission factories
+ * Use this when your permission needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
+ *   role
+ * }) => {
+ *   return pikkuPermission(async ({ logger }, data, session) => {
+ *     if (!session || session.role !== role) {
+ *       logger.warn(\`Permission denied: required role '\${role}'\`)
+ *       return false
+ *     }
+ *     return true
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuPermissionFactory = <In = any>(
+  factory: (input: In) => PikkuPermission<any>
+): ((input: In) => PikkuPermission<any>) => {
+  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.
@@ -106,7 +183,7 @@ export type PikkuFunctionSessionless<
   Out = never,
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Services &
+  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null]
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
@@ -132,7 +209,7 @@ export type PikkuFunction<
   Out = never,
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc'> &
+  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null]
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
@@ -149,12 +226,16 @@ export type PikkuFunction<
  *
  * @template In - The input type
  * @template Out - The output type
+ * @template ChannelData - Channel data type
+ * @template MCPData - MCP data 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>
+  ChannelData = unknown,
+  MCPData = unknown,
+  PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
 
 /**
@@ -181,7 +262,7 @@ export type PikkuFunctionConfig<
 export const pikkuFunc = <In, Out = unknown>(
   func:
     | PikkuFunction<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -238,6 +319,73 @@ export const pikkuVoidFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a Pikku config factory.
+ * Use this to define your application's configuration factory.
+ *
+ * @param func - Config factory function that returns your application's config
+ * @returns The config factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createConfig = pikkuConfig(async () => {
+ *   return {
+ *     apiUrl: process.env.API_URL || 'http://localhost:3000',
+ *     dbUrl: process.env.DATABASE_URL
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuConfig = (
+  func: (variables?: any, ...args: any[]) => Promise<Config>
+) => func
+
+/**
+ * Creates a Pikku singleton services factory.
+ * Use this to define services that are created once and shared across all requests.
+ *
+ * @param func - Singleton services factory function
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuServices(async (config, existingServices) => {
+ *   return {
+ *     config,
+ *     logger: new CustomLogger(),
+ *     db: await createDatabaseConnection(config.dbUrl)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuServices = (
+  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => func
+
+/**
+ * Creates a Pikku session services factory.
+ * Use this to define services that are created per-request/session.
+ *
+ * @param func - Session services factory function
+ * @returns The session services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ *   return {
+ *     userCache: new UserCache(session?.userId)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuSessionServices = (
+  func: (
+    services: SingletonServices,
+    interaction: any,
+    session: Session | undefined
+  ) => Promise<RequiredSessionServices>
+) => func
+
 /**
  * Adds global middleware for a specific tag.
  *
@@ -272,7 +420,7 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * 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.
+ * @param permissions - The permissions array or object to apply for the specified tag.
  *
  * @throws Error if permissions for the tag already exist.
  *
@@ -284,11 +432,11 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * // Add authentication permissions for auth endpoints
  * addPermission('auth', [authPermission])
  *
- * // Add read permissions for all API endpoints
- * addPermission('api', [readPermission])
+ * // Add read permissions for all API endpoints (as object)
+ * addPermission('api', { read: readPermission })
  * \`\`\`
  */
-export const addPermission = <In = unknown>(tag: string, permissions: PikkuPermission<In>[]) => {
+export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
   addPermissionCore(tag, permissions as any)
 }
 `;

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.js

@@ -3,7 +3,6 @@
  */
 export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath) => {
     return `/**
- * This file was generated by the @pikku/cli
  * Main type export hub - re-exports all wiring-specific types
  */
 

package/dist/src/functions/wirings/http/openapi-spec-generator.d.ts

@@ -1,4 +1,5 @@
-import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
+import { FunctionsMeta } from '@pikku/core';
+import { HTTPWiringsMeta } from '@pikku/core/http';
 import { CLILogger } from '../../../services/cli-logger.service.js';
 interface OpenAPISpec {
     openapi: string;

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

@@ -13,11 +13,6 @@ export const pikkuHTTPMap = pikkuSessionlessFunc({
         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/dist/src/functions/wirings/http/pikku-command-http-routes.js

@@ -15,11 +15,6 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         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/dist/src/functions/wirings/http/pikku-command-http-types.js

@@ -14,8 +14,6 @@ export const pikkuHTTPTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating HTTP types',
             commandEnd: 'Created HTTP types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -6,11 +6,16 @@ import { generateOpenAPISpec } from './openapi-spec-generator.js';
 import { stringify } from 'yaml';
 export const pikkuOpenAPI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { http, functions } = await getInspectorState();
         const { tsconfig, openAPI, schemasFromTypes } = config;
+        // If openAPI outputFile is not defined, clean up any existing file and return
         if (!openAPI?.outputFile) {
-            throw new Error('openAPI is required');
+            logger.info({
+                message: 'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
+                type: 'skip',
+            });
+            return;
         }
+        const { http, functions } = await getInspectorState();
         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')) {
@@ -27,8 +32,6 @@ export const pikkuOpenAPI = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating OpenAPI spec',
             commandEnd: 'Created OpenAPI spec',
-            skipCondition: ({ config }) => config.openAPI?.outputFile === undefined,
-            skipMessage: 'openAPI outfile is not defined',
         }),
     ],
 });

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

@@ -15,11 +15,6 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         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/dist/src/functions/wirings/http/serialize-http-types.js

@@ -3,11 +3,10 @@
  */
 export const serializeHTTPTypes = (functionTypesImportPath) => {
     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 { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
 import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
 
@@ -60,5 +59,31 @@ export const addHTTPMiddleware = (
 ) => {
   addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
 }
+
+/**
+ * Registers HTTP permissions either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with permissions, the permissions
+ * are applied only to that route. Permissions can be passed as an array or as a
+ * permission group object.
+ *
+ * @param pattern - Route pattern string (e.g., '*' for all routes, '/api/*' for specific routes)
+ * @param permissions - The permissions to apply for the specified route pattern
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP permissions
+ * addHTTPPermission('*', { global: globalPermission })
+ *
+ * // Add route-specific permissions
+ * addHTTPPermission('/api/admin/*', { admin: adminPermission })
+ * \`\`\`
+ */
+export const addHTTPPermission = <In = unknown>(
+  pattern: string,
+  permissions: Record<string, PikkuPermission<In>> | PikkuPermission<In>[]
+) => {
+  addHTTPPermissionCore(pattern, permissions as any)
+}
 `;
 };

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

@@ -18,11 +18,6 @@ export const pikkuMCPJSON = pikkuSessionlessFunc({
         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',
         }),
     ],
 });

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

@@ -14,8 +14,6 @@ export const pikkuMCPTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating MCP types',
             commandEnd: 'Created MCP types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -61,11 +61,6 @@ pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null
         logCommandInfoAndTime({
             commandStart: 'Finding MCP endpoints',
             commandEnd: 'Found MCP endpoints',
-            skipCondition: async ({ getInspectorState }) => {
-                const { mcpEndpoints } = await getInspectorState();
-                return mcpEndpoints.files.size === 0;
-            },
-            skipMessage: 'none found',
         }),
     ],
 });

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

@@ -1,4 +1,4 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core';
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 import { FunctionsMeta } from '@pikku/core';
 import { TypesMap } from '@pikku/inspector';
 import { CLILogger } from '../../../services/cli-logger.service.js';

package/dist/src/functions/wirings/mcp/serialize-mcp-types.js

@@ -3,7 +3,6 @@
  */
 export const serializeMCPTypes = (functionTypesImportPath) => {
     return `/**
- * This file was generated by the @pikku/cli
  * MCP-specific type definitions for tree-shaking optimization
  */
 
@@ -16,8 +15,9 @@ import {
   wireMCPPrompt as wireMCPPromptCore,
   MCPResourceResponse,
   MCPToolResponse,
-  MCPPromptResponse
-} from '@pikku/core'
+  MCPPromptResponse,
+  AssertMCPResourceURIParams
+} from '@pikku/core/mcp'
 
 import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
 
@@ -25,8 +25,9 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * Type definition for MCP resources that provide data to AI models.
  *
  * @template In - Input type for the resource request
+ * @template URI - URI template string type for compile-time parameter validation
  */
-type MCPResourceWiring<In> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>>
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
 
 /**
  * Type definition for MCP tools that AI models can invoke.
@@ -47,10 +48,11 @@ type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptRespon
  * Resources provide data that AI models can access.
  *
  * @template In - Input type for the resource request
+ * @template URI - URI template string for compile-time parameter validation
  * @param mcpResource - MCP resource definition with data provider function
  */
-export const wireMCPResource = <In>(
-  mcpResource: MCPResourceWiring<In>
+export const wireMCPResource = <In, URI extends string>(
+  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
 ) => {
   wireMCPResourceCore(mcpResource as any)
 }
@@ -96,8 +98,8 @@ export const pikkuMCPPromptFunc = <In>(
         func: PikkuFunctionSessionless<In, MCPPromptResponse>
         name?: string
       }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPPromptResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
@@ -115,8 +117,8 @@ export const pikkuMCPToolFunc = <In>(
       func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
       name?: string
     }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPToolResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
@@ -134,8 +136,8 @@ export const pikkuMCPResourceFunc = <In>(
       func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
       name?: string
     }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPResourceResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 `;
 };

package/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -31,8 +31,6 @@ export const pikkuMiddleware = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Serializing Pikku middleware',
             commandEnd: 'Serialized Pikku middleware',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });