@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,31 @@
+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 { serializeCLITypes } from './serialize-cli-types.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+export const pikkuCLITypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { cliTypesFile, functionTypesFile, packageMappings } = config;
+        const visitState = await getInspectorState();
+        const functionTypesImportPath = getFileImportRelativePath(cliTypesFile, functionTypesFile, packageMappings);
+        // Check for required types
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const { userSessionType, singletonServicesType } = visitState.filesAndMethods;
+        if (!userSessionType || !singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const content = serializeCLITypes(functionTypesImportPath, `import type { ${userSessionType.type} } from '${getFileImportRelativePath(cliTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type);
+        await writeFileInDir(logger, cliTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating CLI types',
+            commandEnd: 'Created CLI types',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,22 @@
+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 pikkuCLI = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { cliWiringsFile, cliWiringMetaFile, packageMappings } = config;
+        const { cli } = visitState;
+        // Generate CLI wirings file
+        await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
+        // Generate CLI metadata file
+        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('cli', 'meta', ${JSON.stringify(cli.meta, null, 2)})`);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding CLI commands',
+            commandEnd: 'Found CLI commands',
+        }),
+    ],
+});

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.d.ts

@@ -0,0 +1,11 @@
+import { CLIProgramMeta } from '@pikku/core/cli';
+import { Config } from '../../../../types/application-types.js';
+/**
+ * Collect all unique renderer names from CLI metadata (populated by inspector)
+ */
+export declare function collectRendererNames(programMeta: CLIProgramMeta): Set<string>;
+/**
+ * Serializes a CLI-over-Channel client bootstrap file
+ * Similar to local CLI bootstrap but uses WebSocket connection
+ */
+export declare function serializeChannelCLIClient(programName: string, programMeta: CLIProgramMeta, clientFile: string, config: Config, cliBootstrapPath: string, channelRoute?: string, renderersMeta?: Record<string, any>): string;

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.js

@@ -0,0 +1,131 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * Collect all unique renderer names from CLI metadata (populated by inspector)
+ */
+export function collectRendererNames(programMeta) {
+    const rendererNames = new Set();
+    // Add program-level default renderer
+    if (programMeta.defaultRenderName) {
+        rendererNames.add(programMeta.defaultRenderName);
+    }
+    // Recursively collect renderer names from commands
+    function collectFromCommand(command) {
+        if (command.renderName) {
+            rendererNames.add(command.renderName);
+        }
+        // Recursively process subcommands
+        if (command.subcommands) {
+            for (const subCommand of Object.values(command.subcommands)) {
+                collectFromCommand(subCommand);
+            }
+        }
+    }
+    // Process all commands
+    for (const command of Object.values(programMeta.commands)) {
+        collectFromCommand(command);
+    }
+    return rendererNames;
+}
+/**
+ * Build a renderers map for CLI commands
+ */
+function buildRenderersMap(programMeta) {
+    const entries = [];
+    // Build map entries for each command that has a renderer
+    function addCommandRenderer(command, path) {
+        const commandId = path.join('.');
+        if (command.renderName) {
+            entries.push(`    '${commandId}': ${command.renderName}`);
+        }
+        // Recursively process subcommands
+        if (command.subcommands) {
+            for (const [subName, subCommand] of Object.entries(command.subcommands)) {
+                addCommandRenderer(subCommand, [...path, subName]);
+            }
+        }
+    }
+    // Process all commands
+    for (const [commandName, command] of Object.entries(programMeta.commands)) {
+        addCommandRenderer(command, [commandName]);
+    }
+    if (entries.length === 0) {
+        return '{}';
+    }
+    return `{\n${entries.join(',\n')}\n  }`;
+}
+/**
+ * Serializes a CLI-over-Channel client bootstrap file
+ * Similar to local CLI bootstrap but uses WebSocket connection
+ */
+export function serializeChannelCLIClient(programName, programMeta, clientFile, config, cliBootstrapPath, channelRoute, renderersMeta) {
+    const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
+    const finalChannelRoute = channelRoute || `/cli/${programName}`;
+    // Get relative import path to CLI bootstrap (for metadata)
+    const bootstrapImportPath = getFileImportRelativePath(clientFile, cliBootstrapPath, config.packageMappings);
+    // Collect all unique renderer names from CLI metadata (populated by inspector)
+    const rendererNames = collectRendererNames(programMeta);
+    // Generate renderer imports from their source files
+    let rendererImports = '';
+    if (rendererNames.size > 0 && renderersMeta) {
+        const importsByFile = new Map();
+        for (const rendererName of rendererNames) {
+            const meta = renderersMeta[rendererName];
+            if (meta?.exportedName && meta?.filePath) {
+                const relativePath = getFileImportRelativePath(clientFile, meta.filePath, config.packageMappings);
+                if (!importsByFile.has(relativePath)) {
+                    importsByFile.set(relativePath, []);
+                }
+                importsByFile.get(relativePath).push(meta.exportedName);
+            }
+        }
+        // Generate import statements
+        for (const [path, names] of importsByFile) {
+            rendererImports += `import { ${names.join(', ')} } from '${path}'\n`;
+        }
+    }
+    // Build renderers map
+    const renderersMap = buildRenderersMap(programMeta);
+    // Determine default renderer
+    const defaultRendererCode = programMeta.defaultRenderName
+        ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
+        : '';
+    return `
+import { executeCLIViaChannel } from '@pikku/core/cli/channel'
+import { CorePikkuWebsocket } from '@pikku/websocket'
+import '${bootstrapImportPath}'
+${rendererImports}
+/**
+ * ${capitalizedName} CLI Client (via WebSocket Channel)
+ * Executes CLI commands over a WebSocket connection
+ */
+export async function ${capitalizedName}CLIClient(
+  url: string,
+  args?: string[]
+): Promise<void> {
+  // Create WebSocket connection
+  const pikkuWS = new CorePikkuWebsocket(url)
+
+  // Register renderers for CLI commands
+  const renderers = ${renderersMap}
+
+  await executeCLIViaChannel({
+    programName: '${programName}',
+    pikkuWS,
+    args,
+    renderers${defaultRendererCode},
+  })
+}
+
+// Export as default for easy importing
+export default ${capitalizedName}CLIClient
+
+// For direct execution (if this file is run directly)
+if (import.meta.url === \`file://\${process.argv[1]}\`) {
+  const url = process.env.PIKKU_WS_URL || 'ws://localhost:3000${finalChannelRoute}'
+  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
+    console.error('Fatal error:', error.message)
+    process.exit(1)
+  })
+}
+`;
+}

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

@@ -0,0 +1,9 @@
+import { CLIProgramMeta } from '@pikku/core/cli';
+/**
+ * Serializes a wireChannel call from CLI metadata
+ * This creates a WebSocket backend for all CLI commands
+ */
+export declare function serializeChannelCLI(programName: string, programMeta: CLIProgramMeta, channelFile: string, functionFiles: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings: Record<string, string>, channelTypesFile: string, functionTypesFile: string, channelName?: string, channelRoute?: string): string;

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

@@ -0,0 +1,67 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * Serializes a wireChannel call from CLI metadata
+ * This creates a WebSocket backend for all CLI commands
+ */
+export function serializeChannelCLI(programName, programMeta, channelFile, functionFiles, packageMappings, channelTypesFile, functionTypesFile, channelName, channelRoute) {
+    const finalChannelName = channelName || `${programName}-cli`;
+    const finalChannelRoute = channelRoute || `/cli/${programName}`;
+    // Flatten all commands into a single routing map
+    const commandMap = {};
+    const collectCommands = (commands, path = []) => {
+        for (const [name, cmd] of Object.entries(commands)) {
+            const fullPath = [...path, name];
+            const commandKey = fullPath.join('.');
+            if (cmd.pikkuFuncName) {
+                commandMap[commandKey] = {
+                    pikkuFuncName: cmd.pikkuFuncName,
+                };
+            }
+            // Recursively process subcommands
+            if (cmd.subcommands) {
+                collectCommands(cmd.subcommands, fullPath);
+            }
+        }
+    };
+    collectCommands(programMeta.commands);
+    // Generate the wireChannel call
+    const commandEntries = Object.entries(commandMap)
+        .map(([commandKey, { pikkuFuncName }]) => {
+        return `      '${commandKey}': ${pikkuFuncName}`;
+    })
+        .join(',\n');
+    // Generate imports from function file locations
+    const funcNames = [
+        ...new Set(Object.values(commandMap).map((v) => v.pikkuFuncName)),
+    ];
+    const imports = funcNames
+        .map((pikkuFuncName) => {
+        const fileInfo = functionFiles.get(pikkuFuncName);
+        if (!fileInfo) {
+            throw new Error(`Function not found in files map: ${pikkuFuncName}`);
+        }
+        const importPath = getFileImportRelativePath(channelFile, fileInfo.path, packageMappings);
+        return `import { ${fileInfo.exportedName} } from '${importPath}'`;
+    })
+        .join('\n');
+    // Get relative path to channel types file
+    const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, packageMappings);
+    return `/**
+ * WebSocket channel backend for '${programName}' CLI commands
+ */
+import { wireChannel } from '${channelTypesPath}'
+${imports}
+
+wireChannel({
+  name: '${finalChannelName}',
+  route: '${finalChannelRoute}',
+  auth: false,
+  onMessageWiring: {
+    command: {
+${commandEntries}
+    }
+  },
+  tags: ['cli', '${programName}']
+})
+`;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Generates type definitions for CLI wirings
+ */
+export declare const serializeCLITypes: (functionTypesImportPath: string, userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string) => string;

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

@@ -0,0 +1,73 @@
+/**
+ * Generates type definitions for CLI wirings
+ */
+export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName) => {
+    return `/**
+
+ * CLI-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
+import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+
+/**
+ * Type-safe CLI renderer definition that can access your application's services.
+ * Use this to define custom renderers for CLI command output.
+ *
+ * @template Data - The output data type from the CLI command
+ * @template RequiredServices - The services required for this renderer
+ */
+type PikkuCLIRender<Data, RequiredServices extends SingletonServices = SingletonServices> = CorePikkuCLIRender<Data, RequiredServices, Session>
+
+/**
+ * CLI command configuration with project-specific types.
+ * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
+ */
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
+
+/**
+ * Type definition for CLI applications with commands and global options.
+ *
+ * @template Commands - Type describing the command structure
+ * @template GlobalOptions - Type for global CLI options
+ */
+type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
+
+/**
+ * Registers a CLI application with the Pikku framework.
+ * Creates command-line interfaces with type-safe commands and options.
+ *
+ * @template Commands - Type describing the command structure
+ * @template GlobalOptions - Type for global CLI options
+ * @param cli - CLI definition with program name, commands, and global options
+ */
+export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions>(
+  cli: CLIWiring<Commands, GlobalOptions>
+) => {
+  wireCLICore(cli as any)
+}
+
+/**
+ * Creates a CLI command definition with automatic option inference from the function's input type.
+ * This allows TypeScript to automatically derive CLI options from the function signature.
+ *
+ * @template FuncConfig - The Pikku function config type
+ * @template Params - The parameters string literal type
+ * @param config - CLI command configuration
+ * @returns CLI command configuration with inferred types
+ */
+export const pikkuCLICommand = <
+  FuncConfig extends PikkuFunctionConfig<any, any>,
+  Params extends string
+>(
+  config: CLICommandConfig<FuncConfig, any, any, Params>
+): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
+  return config as any
+}
+`;
+};

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.d.ts

@@ -0,0 +1,14 @@
+import { Config } from '../../../../types/application-types.js';
+/**
+ * Serializes the local (in-program) CLI bootstrap code
+ */
+export declare function serializeLocalCLIBootstrap(programName: string, _programMeta: any, bootstrapFile: string, config: Config, pikkuConfigFactory: {
+    file: string;
+    variable: string;
+}, singletonServicesFactory: {
+    file: string;
+    variable: string;
+}, sessionServicesFactory: {
+    file: string;
+    variable: string;
+}): string;

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.js

@@ -0,0 +1,51 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * Serializes the local (in-program) CLI bootstrap code
+ */
+export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory) {
+    const capitalizedName = programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '');
+    // Get relative import paths
+    const pikkuConfigPath = getFileImportRelativePath(bootstrapFile, pikkuConfigFactory.file, config.packageMappings);
+    const singletonServicesPath = getFileImportRelativePath(bootstrapFile, singletonServicesFactory.file, config.packageMappings);
+    const sessionServicesPath = getFileImportRelativePath(bootstrapFile, sessionServicesFactory.file, config.packageMappings);
+    const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
+    return `
+import { executeCLI, CLIError } from '@pikku/core/cli'
+import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
+import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
+import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+import '${cliBootstrapPath}'
+
+/**
+ * ${capitalizedName} CLI function
+ * Handles command line arguments and executes the appropriate function
+ */
+export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
+  try {
+    await executeCLI({
+      programName: '${programName}',
+      args: args || process.argv.slice(2),
+      createConfig,
+      createSingletonServices,
+      createSessionServices,
+    })
+  } catch (error) {
+    if (error instanceof CLIError) {
+      process.exit(error.exitCode)
+    }
+    throw error
+  }
+}
+
+// Export as default for easy importing
+export default ${capitalizedName}CLI
+
+// For direct execution (if this file is run directly)
+if (import.meta.url === \`file://\${process.argv[1]}\`) {
+  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
+    console.error('Fatal error:', error.message)
+    process.exit(1)
+  })
+}
+`;
+}

package/dist/src/functions/wirings/fetch/index.d.ts

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

package/dist/src/functions/wirings/fetch/index.js

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+export const pikkuFetch = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
+        // If fetchFile is not set, clean up any existing file and return
+        if (!fetchFile) {
+            logger.info({
+                message: "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpMapDeclarationFile, packageMappings);
+        const content = [serializeFetchWrapper(routesMapDeclarationPath)];
+        await writeFileInDir(logger, fetchFile, content.join('\n'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating fetch wrapper',
+            commandEnd: 'Generated fetch wrapper',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
+import { serializeFunctionTypes } from './serialize-function-types.js';
+export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { functionTypesFile, packageMappings, rpcInternalMapDeclarationFile, servicesFile, } = config;
+        // Check for required types
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const { userSessionType, sessionServicesType, singletonServicesType, pikkuConfigType, } = visitState.filesAndMethods;
+        if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport);
+        await writeFileInDir(logger, functionTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating function types',
+            commandEnd: 'Created function types',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,18 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
+export const pikkuFunctionTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        await writeFileInDir(logger, typesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating api types hub',
+            commandEnd: 'Created api types hub',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,26 @@
+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 { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+export const pikkuFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { functions, rpc } = await getInspectorState();
+        const { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings, } = config;
+        // Generate full metadata
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+        // Generate minimal metadata (runtime)
+        const runtimeMeta = generateRuntimeMeta(functions.meta);
+        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`);
+        const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
+        if (hasRPCs) {
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        }
+        return hasRPCs;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing Pikku functions',
+            commandEnd: 'Serialized Pikku functions',
+        }),
+    ],
+});

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

@@ -0,0 +1,2 @@
+export declare const serializeServicesMap: (requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const pikkuServices: any;

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

@@ -1,21 +1,20 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
-    // Extract all unique services from all functions
-    const usedServices = new Set();
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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 = (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);
         }
@@ -36,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'",
@@ -59,15 +54,27 @@ export const serializeServicesMap = (functionsMetaData, middlewareServices = [],
     ].join('\n');
     return code;
 };
-export const pikkuServices = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [false], async () => {
-        const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
+export const pikkuServices = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        // Check for required types
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`;
-        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.functions.meta, cliConfig.middlewareServices, servicesImport, sessionServicesImport);
-        await writeFileInDir(logger, cliConfig.servicesFile, servicesCode);
-    });
-};
+        const { sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
+        if (!sessionServicesType || !singletonServicesType) {
+            throw new Error('Required types not found: sessionServicesType or singletonServicesType');
+        }
+        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.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, sessionServicesImport);
+        await writeFileInDir(logger, config.servicesFile, servicesCode);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Pikku services map',
+            commandEnd: 'Generated Pikku services map',
+        }),
+    ],
+});

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

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