@pikku/cli 0.11.1 → 0.11.3

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

@@ -2,13 +2,29 @@ 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 { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config;
+        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = 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)})`);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(http.meta);
+        await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(http.meta)) {
+            const verbosePath = httpWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(http.meta, null, 2));
+        }
+        // Generate TypeScript file that imports the minimal JSON
+        const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -15,8 +15,8 @@ export const pikkuOpenAPI = pikkuSessionlessFunc({
             });
             return;
         }
-        const { http, functions } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties);
+        const { http, functions, zodLookup } = await getInspectorState();
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties, zodLookup);
         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 });

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

@@ -2,13 +2,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';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config;
+        const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = 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)})`);
+        await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(http.meta, null, 2));
+        const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -8,7 +8,7 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
 
 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'
+import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -18,7 +18,23 @@ import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
  * @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>
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * HTTP wiring for workflow triggers (no function needed)
+ */
+type HTTPWorkflowWiring<Route extends string> = {
+  route: Route
+  method: HTTPMethod
+  workflow: true
+  func?: undefined
+  permissions?: undefined
+  auth?: undefined
+  tags?: undefined
+  middleware?: undefined
+  returnsJSON?: undefined
+  sse?: boolean
+}
 
 /**
  * Registers an HTTP wiring with the Pikku framework.
@@ -29,7 +45,7 @@ type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out,
  * @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>
+  httpWiring: (HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>) | HTTPWorkflowWiring<Route>
 ) => {
   wireHTTPCore(httpWiring as any)
 }

package/dist/src/functions/wirings/http/serialize-typed-http-map.js

@@ -9,7 +9,7 @@ export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, ty
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
@@ -37,21 +37,39 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
     for (const methods of Object.values(routesMeta)) {
         for (const meta of Object.values(methods)) {
             const { route, method, pikkuFuncName } = meta;
+            // Skip workflow-triggered routes (they don't have a function)
+            if (meta.workflow) {
+                continue;
+            }
             const functionMeta = functionsMeta[pikkuFuncName];
             if (!functionMeta) {
                 throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
             }
             const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
             const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-            // Initialize the route entry if it doesn't exist
             if (!routesObj[route]) {
                 routesObj[route] = {};
             }
-            // Store the input and output types separately for RouteHandler
-            const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-            const outputType = output
-                ? typesMap.getTypeMeta(output).uniqueName
-                : 'null';
+            // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
+            let inputType = 'null';
+            if (input) {
+                try {
+                    inputType = typesMap.getTypeMeta(input).uniqueName;
+                }
+                catch {
+                    inputType = input;
+                }
+            }
+            let outputType = 'null';
+            if (output) {
+                try {
+                    outputType = typesMap.getTypeMeta(output).uniqueName;
+                }
+                catch {
+                    // Zod-derived schema - use the schema name directly
+                    outputType = output;
+                }
+            }
             requiredTypes.add(inputType);
             requiredTypes.add(outputType);
             // Add method entry
@@ -75,7 +93,14 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
 }
 const generateMetaTypes = (metaTypes, typesMap) => {
     const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
-        const { uniqueName } = typesMap.getTypeMeta(_name);
+        let uniqueName;
+        try {
+            uniqueName = typesMap.getTypeMeta(_name).uniqueName;
+        }
+        catch {
+            // Zod-derived schema - use the name directly
+            uniqueName = _name;
+        }
         const queryType = query && query.length > 0
             ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
             : undefined;

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

@@ -4,6 +4,8 @@ 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';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
@@ -14,8 +16,8 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
     const uniqueName = typesMap.getUniqueName(inputSchema);
     if (!uniqueName)
         return [];
+    const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
     try {
-        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
         const schemaContent = await readFile(schemaPath, 'utf-8');
         const schema = JSON.parse(schemaContent);
         const argumentsArray = [];
@@ -33,14 +35,15 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
         return argumentsArray;
     }
     catch (e) {
-        logger.warn(`Could not load schema for type: ${uniqueName}`);
+        logger.warn(`Command MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`);
+        console.error(e);
         return [];
     }
 };
 export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
-        const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, } = config;
+        const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
         await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
@@ -51,10 +54,30 @@ export const pikkuMCP = pikkuSessionlessFunc({
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
             }
         }
+        const metaData = {
+            resourcesMeta: mcpEndpoints.resourcesMeta,
+            toolsMeta: mcpEndpoints.toolsMeta,
+            promptsMeta: promptsMetaWithArguments,
+        };
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(metaData);
+        await writeFileInDir(logger, config.mcpWiringsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(metaData)) {
+            const verbosePath = config.mcpWiringsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(mcpWiringsMetaFile, config.mcpWiringsMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
         await writeFileInDir(logger, mcpWiringsMetaFile, `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)})`);
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+${importStatement}
+pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
+pikkuState(null, 'mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
+pikkuState(null, 'mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`);
         return true;
     },
     middleware: [

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

@@ -14,13 +14,14 @@ export const serializeMCPJson = async (logger, schemaDirectory, functionsMeta, t
         if (!uniqueName) {
             return undefined;
         }
+        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
         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}`);
+            logger.warn(`Serialize MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`);
+            console.error(e);
             return undefined;
         }
     };

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

@@ -19,7 +19,8 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
+import type { ZodLike } from '@pikku/core'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -27,21 +28,21 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * @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 MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { 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 MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * 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>>
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Registers an MCP resource with the Pikku framework.
@@ -83,60 +84,111 @@ export const wireMCPPrompt = <In>(
   wireMCPPromptCore(mcpPrompt as any)
 }
 
+/**
+ * Configuration for MCP prompt with Zod schema input validation.
+ */
+type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP prompt requests.
  * These functions generate prompt templates for AI models.
  *
- * @template In - Input type for the prompt parameters
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPPromptFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPPromptFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the prompt parameters (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPPromptFunc = <In>(
+export function pikkuMCPPromptFunc<InputSchema extends ZodLike>(
+  config: MCPPromptFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
     | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
         name?: string
       }
-): PikkuFunctionConfig<In, MCPPromptResponse> => {
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP tool with Zod schema input validation.
+ */
+type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * 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
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPToolFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPToolFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the tool invocation (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPToolFunc = <In>(
+export function pikkuMCPToolFunc<InputSchema extends ZodLike>(
+  config: MCPToolFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPToolResponse> => {
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP resource with Zod schema input validation.
+ */
+type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * 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
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPResourceFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPResourceFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the resource request (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPResourceFunc = <In>(
+export function pikkuMCPResourceFunc<InputSchema extends ZodLike>(
+  config: MCPResourceFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPResourceResponse> => {
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 `;

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

@@ -3,17 +3,44 @@ 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';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { middleware } = state;
-        const { middlewareFile, packageMappings } = config;
+        const { middlewareFile, packageMappings, schema } = config;
         let filesGenerated = false;
         // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
         if (hasHTTPGroups || hasTagGroups) {
-            await writeFileInDir(logger, config.middlewareGroupsMetaFile, serializeMiddlewareGroupsMeta(state));
+            const metaData = serializeMiddlewareGroupsMeta(state);
+            // Write JSON file
+            await writeFileInDir(logger, config.middlewareGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
+            // Calculate relative path from TS file to JSON file
+            const jsonImportPath = getFileImportRelativePath(config.middlewareGroupsMetaFile, config.middlewareGroupsMetaJsonFile, packageMappings);
+            // Write TypeScript file that imports JSON
+            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+            const importStatement = supportsImportAttributes
+                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+                : `import metaData from '${jsonImportPath}'`;
+            const packageNameValue = config.externalPackageName
+                ? `'${config.externalPackageName}'`
+                : 'null';
+            const tsContent = `import { pikkuState } from '@pikku/core'
+${importStatement}
+
+// HTTP middleware groups metadata
+if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
+  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
+}
+
+// Tag middleware groups metadata
+if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
+  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
+}
+`;
+            await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);
             // Always generate middleware imports file when groups exist (even if empty)
             await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
             filesGenerated = true;

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

@@ -1,8 +1,11 @@
 import type { InspectorState } from '@pikku/inspector';
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata 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;
+export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => {
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+};

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

@@ -1,11 +1,10 @@
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata 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()) {
@@ -18,11 +17,6 @@ export const serializeMiddlewareGroupsMeta = (state) => {
             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()) {
@@ -35,10 +29,8 @@ export const serializeMiddlewareGroupsMeta = (state) => {
             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');
+    return {
+        httpGroups,
+        tagGroups,
+    };
 };

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

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

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

@@ -0,0 +1,58 @@
+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 { serializePackageFactories } from './serialize-package.js';
+export const pikkuPackage = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { externalPackageName, packageMappings, packageFile } = config;
+        // Only generate for external packages
+        if (!externalPackageName) {
+            logger.info({
+                message: 'Skipping package factories - not an external package (externalPackageName not set)',
+                type: 'skip',
+            });
+            return false;
+        }
+        if (!packageFile) {
+            logger.info({
+                message: 'Skipping package factories - packageFile not configured',
+                type: 'skip',
+            });
+            return false;
+        }
+        const state = await getInspectorState();
+        const { filesAndMethods } = state;
+        const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = filesAndMethods;
+        const content = serializePackageFactories(packageFile, externalPackageName, pikkuConfigFactory
+            ? {
+                file: pikkuConfigFactory.file,
+                variable: pikkuConfigFactory.variable,
+            }
+            : undefined, singletonServicesFactory
+            ? {
+                file: singletonServicesFactory.file,
+                variable: singletonServicesFactory.variable,
+            }
+            : undefined, wireServicesFactory
+            ? {
+                file: wireServicesFactory.file,
+                variable: wireServicesFactory.variable,
+            }
+            : undefined, packageMappings);
+        if (!content) {
+            logger.info({
+                message: 'Skipping package factories - no service factories found',
+                type: 'skip',
+            });
+            return false;
+        }
+        await writeFileInDir(logger, packageFile, content);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating package service factories',
+            commandEnd: 'Generated package service factories',
+        }),
+    ],
+});

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

@@ -0,0 +1,5 @@
+export interface PackageFactoryInfo {
+    file: string;
+    variable: string;
+}
+export declare const serializePackageFactories: (outputPath: string, packageName: string, configFactory: PackageFactoryInfo | undefined, singletonServicesFactory: PackageFactoryInfo | undefined, wireServicesFactory: PackageFactoryInfo | undefined, packageMappings?: Record<string, string>) => string | null;

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

@@ -0,0 +1,32 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
+    const imports = [
+        `import { addPackageServiceFactories } from '@pikku/core'`,
+    ];
+    const factoryEntries = [];
+    if (configFactory) {
+        const filePath = getFileImportRelativePath(outputPath, configFactory.file, packageMappings);
+        imports.push(`import { ${configFactory.variable} as createConfig } from '${filePath}'`);
+        factoryEntries.push(`  createConfig,`);
+    }
+    if (singletonServicesFactory) {
+        const filePath = getFileImportRelativePath(outputPath, singletonServicesFactory.file, packageMappings);
+        imports.push(`import { ${singletonServicesFactory.variable} as createSingletonServices } from '${filePath}'`);
+        factoryEntries.push(`  createSingletonServices,`);
+    }
+    if (wireServicesFactory) {
+        const filePath = getFileImportRelativePath(outputPath, wireServicesFactory.file, packageMappings);
+        imports.push(`import { ${wireServicesFactory.variable} as createWireServices } from '${filePath}'`);
+        factoryEntries.push(`  createWireServices,`);
+    }
+    // Only generate if at least one factory is defined
+    if (factoryEntries.length === 0) {
+        return null;
+    }
+    return `${imports.join('\n')}
+
+addPackageServiceFactories('${packageName}', {
+${factoryEntries.join('\n')}
+})
+`;
+};