@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,19 @@
+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 = pikkuSessionlessFunc({
+    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',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuOpenAPI: any;

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

@@ -0,0 +1,37 @@
+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 = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { tsconfig, openAPI, schemasFromTypes } = config;
+        // If openAPI outputFile is not defined, clean up any existing file and return
+        if (!openAPI?.outputFile) {
+            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')) {
+            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',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuHTTP: any;

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

@@ -0,0 +1,20 @@
+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 = pikkuSessionlessFunc({
+    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',
+        }),
+    ],
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for HTTP wirings
+ */
+export declare const serializeHTTPTypes: (functionTypesImportPath: string) => string;

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

@@ -0,0 +1,89 @@
+/**
+ * Generates type definitions for HTTP wirings
+ */
+export const serializeHTTPTypes = (functionTypesImportPath) => {
+    return `/**
+ * HTTP-specific type definitions for tree-shaking optimization
+ */
+
+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'
+
+/**
+ * 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)
+}
+
+/**
+ * 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/{wirings → functions/wirings}/http/serialize-typed-http-map.js

@@ -1,5 +1,5 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
 export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);

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

@@ -0,0 +1 @@
+export declare const pikkuMCPJSON: any;

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

@@ -0,0 +1,23 @@
+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 = pikkuSessionlessFunc({
+    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',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuMCPTypes: any;

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

@@ -0,0 +1,19 @@
+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 { serializeMCPTypes } from './serialize-mcp-types.js';
+export const pikkuMCPTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { mcpTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(mcpTypesFile, functionTypesFile, packageMappings);
+        const content = serializeMCPTypes(functionTypesImportPath);
+        await writeFileInDir(logger, mcpTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating MCP types',
+            commandEnd: 'Created MCP types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/mcp/pikku-command-mcp.d.ts

@@ -0,0 +1 @@
+export declare const pikkuMCP: any;

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

@@ -1,4 +1,7 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+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';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
 // Helper function to generate arguments from schema
@@ -34,8 +37,10 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
         return [];
     }
 };
-export const pikkuMCP = async (logger, { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
-    return await logCommandInfoAndTime(logger, 'Finding MCP endpoints', 'Found MCP endpoints', [mcpEndpoints.files.size === 0], async () => {
+export const pikkuMCP = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { mcpEndpoints, functions } = await getInspectorState();
+        const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, } = config;
         await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
@@ -50,5 +55,12 @@ export const pikkuMCP = async (logger, { mcpWiringsFile, mcpWiringsMetaFile, pac
 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)})`);
-    });
-};
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding MCP endpoints',
+            commandEnd: 'Found MCP endpoints',
+        }),
+    ],
+});

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

@@ -1,5 +1,5 @@
-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 '../../utils.js';
+import { CLILogger } from '../../../services/cli-logger.service.js';
 export declare const serializeMCPJson: (logger: CLILogger, schemaDirectory: string, functionsMeta: FunctionsMeta, typesMap: TypesMap, mcpResourceMeta: MCPResourceMeta, mcpToolMeta: MCPToolMeta, mcpPromptMeta: MCPPromptMeta) => Promise<string>;

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for MCP wirings
+ */
+export declare const serializeMCPTypes: (functionTypesImportPath: string) => string;

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

@@ -0,0 +1,143 @@
+/**
+ * Generates type definitions for MCP wirings
+ */
+export const serializeMCPTypes = (functionTypesImportPath) => {
+    return `/**
+ * MCP-specific type definitions for tree-shaking optimization
+ */
+
+import {
+  CoreMCPResource,
+  CoreMCPTool,
+  CoreMCPPrompt,
+  wireMCPResource as wireMCPResourceCore,
+  wireMCPTool as wireMCPToolCore,
+  wireMCPPrompt as wireMCPPromptCore,
+  MCPResourceResponse,
+  MCPToolResponse,
+  MCPPromptResponse,
+  AssertMCPResourceURIParams
+} from '@pikku/core/mcp'
+
+import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+
+/**
+ * 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, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
+
+/**
+ * Type definition for MCP tools that AI models can invoke.
+ *
+ * @template In - Input type for the tool invocation
+ */
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse>>
+
+/**
+ * Type definition for MCP prompts that provide templates to AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ */
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse>>
+
+/**
+ * Registers an MCP resource with the Pikku framework.
+ * 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, URI extends string>(
+  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
+) => {
+  wireMCPResourceCore(mcpResource as any)
+}
+
+/**
+ * Registers an MCP tool with the Pikku framework.
+ * Tools are functions that AI models can invoke.
+ *
+ * @template In - Input type for the tool invocation
+ * @param mcpTool - MCP tool definition with action function
+ */
+export const wireMCPTool = <In>(
+  mcpTool: MCPToolWiring<In>
+) => {
+  wireMCPToolCore(mcpTool as any)
+}
+
+/**
+ * Registers an MCP prompt with the Pikku framework.
+ * Prompts provide templates that AI models can use.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param mcpPrompt - MCP prompt definition with template function
+ */
+export const wireMCPPrompt = <In>(
+  mcpPrompt: MCPPromptWiring<In>
+) => {
+  wireMCPPromptCore(mcpPrompt as any)
+}
+
+/**
+ * Creates a function for handling MCP prompt requests.
+ * These functions generate prompt templates for AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPPromptFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | {
+        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        name?: string
+      }
+): PikkuFunctionConfig<In, MCPPromptResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function for handling MCP tool invocations.
+ * These functions perform actions that AI models can request.
+ *
+ * @template In - Input type for the tool invocation
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPToolFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      name?: string
+    }
+): PikkuFunctionConfig<In, MCPToolResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function for handling MCP resource requests.
+ * These functions provide data that AI models can access.
+ *
+ * @template In - Input type for the resource request
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPResourceFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      name?: string
+    }
+): PikkuFunctionConfig<In, MCPResourceResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+`;
+};

package/dist/src/functions/wirings/middleware/pikku-command-middleware.d.ts

@@ -0,0 +1 @@
+export declare const pikkuMiddleware: any;

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

@@ -0,0 +1,36 @@
+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 { serializeMiddlewareImports } from './serialize-middleware-imports.js';
+import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js';
+export const pikkuMiddleware = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { middleware } = state;
+        const { middlewareFile, packageMappings } = config;
+        let filesGenerated = false;
+        // Check if there are any middleware group factories
+        const hasHTTPFactories = Array.from(state.http.routeMiddleware.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasTagFactories = Array.from(state.middleware.tagMiddleware.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasFactories = hasHTTPFactories || hasTagFactories;
+        // Generate middleware imports file if there are factories
+        if (hasFactories) {
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
+            filesGenerated = true;
+        }
+        // Generate middleware groups metadata file
+        const hasHTTPGroups = state.http.routeMiddleware.size > 0;
+        const hasTagGroups = state.middleware.tagMiddleware.size > 0;
+        if (hasHTTPGroups || hasTagGroups) {
+            await writeFileInDir(logger, config.middlewareGroupsMetaFile, serializeMiddlewareGroupsMeta(state));
+            filesGenerated = true;
+        }
+        return filesGenerated;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing Pikku middleware',
+            commandEnd: 'Serialized Pikku middleware',
+        }),
+    ],
+});

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.d.ts

@@ -0,0 +1,8 @@
+import type { InspectorState } from '@pikku/inspector';
+/**
+ * Generates the middleware groups metadata file that stores metadata about
+ * tag-based and HTTP middleware groups for visualization and inspection.
+ *
+ * This includes services, middleware count, factory status, etc.
+ */
+export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => string;

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.js

@@ -0,0 +1,44 @@
+/**
+ * Generates the middleware groups metadata file that stores metadata about
+ * tag-based and HTTP middleware groups for visualization and inspection.
+ *
+ * This includes services, middleware count, factory status, etc.
+ */
+export const serializeMiddlewareGroupsMeta = (state) => {
+    const lines = [`import { pikkuState } from '@pikku/core'`, ``];
+    // Serialize HTTP middleware groups metadata
+    const httpGroups = {};
+    for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
+        httpGroups[pattern] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            middlewareCount: meta.middlewareCount,
+            isFactory: meta.isFactory,
+        };
+    }
+    if (Object.keys(httpGroups).length > 0) {
+        lines.push(`// HTTP middleware groups metadata`);
+        lines.push(`pikkuState('middleware', 'httpGroupMeta', ${JSON.stringify(httpGroups, null, 2)})`);
+        lines.push(``);
+    }
+    // Serialize tag middleware groups metadata
+    const tagGroups = {};
+    for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
+        tagGroups[tag] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            middlewareCount: meta.middlewareCount,
+            isFactory: meta.isFactory,
+        };
+    }
+    if (Object.keys(tagGroups).length > 0) {
+        lines.push(`// Tag middleware groups metadata`);
+        lines.push(`pikkuState('middleware', 'tagGroupMeta', ${JSON.stringify(tagGroups, null, 2)})`);
+        lines.push(``);
+    }
+    return lines.join('\n');
+};

package/dist/src/functions/wirings/middleware/serialize-middleware-imports.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorMiddlewareState, InspectorHTTPState, InspectorState } from '@pikku/inspector';
+export declare const serializeMiddlewareImports: (outputPath: string, middlewareState: InspectorMiddlewareState, httpState: InspectorHTTPState, packageMappings?: Record<string, string>, fullState?: InspectorState) => string;

package/dist/src/functions/wirings/middleware/serialize-middleware-imports.js

@@ -0,0 +1,43 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
+    const serializedImports = [];
+    const serializedFactoryCalls = [];
+    // Collect factory imports and calls for HTTP middleware groups
+    const httpFactories = new Map();
+    for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
+        if (groupMeta.exportName && groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            httpFactories.set(groupMeta.exportName, {
+                exportName: groupMeta.exportName,
+                filePath,
+            });
+        }
+    }
+    // Collect factory imports and calls for tag middleware groups
+    const tagFactories = new Map();
+    for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+        if (groupMeta.exportName && groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            tagFactories.set(groupMeta.exportName, {
+                exportName: groupMeta.exportName,
+                filePath,
+            });
+        }
+    }
+    // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
+    const allFactories = new Map([...httpFactories, ...tagFactories]);
+    // Add factory imports and calls
+    if (allFactories.size > 0) {
+        serializedImports.push('/* Call middleware group factories to register at module evaluation */');
+        // Import factories
+        for (const [exportName, { filePath }] of allFactories) {
+            serializedImports.push(`import { ${exportName} } from '${filePath}'`);
+        }
+        // Call factories
+        for (const [exportName] of allFactories) {
+            serializedFactoryCalls.push(`${exportName}()`);
+        }
+    }
+    // Return combined output
+    return [...serializedImports, ...serializedFactoryCalls].join('\n');
+};

package/dist/src/functions/wirings/permissions/pikku-command-permissions.d.ts

@@ -0,0 +1 @@
+export declare const pikkuPermissions: any;

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

@@ -0,0 +1,28 @@
+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 { serializePermissionsImports } from './serialize-permissions-imports.js';
+export const pikkuPermissions = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { permissions } = state;
+        const { permissionsFile, packageMappings } = config;
+        let filesGenerated = false;
+        // Check if there are any permission group factories
+        const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasFactories = hasHTTPFactories || hasTagFactories;
+        // Generate permissions imports file if there are factories
+        if (hasFactories) {
+            await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
+            filesGenerated = true;
+        }
+        return filesGenerated;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing Pikku permissions',
+            commandEnd: 'Serialized Pikku permissions',
+        }),
+    ],
+});

package/dist/src/functions/wirings/permissions/serialize-permissions-imports.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorPermissionState, InspectorHTTPState, InspectorState } from '@pikku/inspector';
+export declare const serializePermissionsImports: (outputPath: string, permissionsState: InspectorPermissionState, httpState: InspectorHTTPState, packageMappings?: Record<string, string>, fullState?: InspectorState) => string;