@pikku/cli 0.9.14 → 0.9.16-next.0

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

@@ -0,0 +1,25 @@
+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 pikkuChannels = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = config;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Channels',
+            commandEnd: 'Found channels',
+            skipCondition: async ({ getInspectorState }) => {
+                const visitState = await getInspectorState();
+                return visitState.channels.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

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

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

package/dist/src/functions/wirings/channels/pikku-command-websocket-typed.js

@@ -0,0 +1,24 @@
+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 { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js';
+export const pikkuWebSocketTyped = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { websocketFile, channelsMapDeclarationFile, packageMappings } = config;
+        if (!websocketFile) {
+            throw new Error("fetchFile is isn't set in the pikku config");
+        }
+        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
+        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
+        await writeFileInDir(logger, websocketFile, content.join('\n'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating websocket wrapper',
+            commandEnd: 'Generated websocket wrapper',
+            skipCondition: ({ config }) => config.websocketFile === undefined,
+            skipMessage: "websocketFile isn't set in the pikku config",
+        }),
+    ],
+});

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

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

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -0,0 +1,95 @@
+/**
+ * Generates type definitions for WebSocket channel wirings
+ */
+export const serializeChannelTypes = (functionTypesImportPath) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * Channel-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
+import { CorePikkuFunctionConfig } from '@pikku/core'
+import { AssertHTTPWiringParams } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for WebSocket channels with typed data exchange.
+ * Supports connection, disconnection, and message handling.
+ *
+ * @template ChannelData - Type of data exchanged through the channel
+ * @template Channel - String literal type for the channel name
+ */
+type ChannelWiringFunction<I, O, C = {}> = PikkuFunctionSessionless<I, O, C> | PikkuFunction<I, O, C>
+type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<ChannelData, Channel, ChannelWiringFunction<void, unknown> | ChannelWiringFunction<void, unknown, ChannelData>, ChannelWiringFunction<void, void> | ChannelWiringFunction<void, void, ChannelData>, ChannelWiringFunction<any, any> | ChannelWiringFunction<any, any, ChannelData>, PikkuPermission, PikkuMiddleware>
+
+/**
+ * Creates a function that handles WebSocket channel connections.
+ * Called when a client connects to a channel.
+ *
+ * @template Out - Output type for connection response
+ * @template ChannelData - Type of data associated with the channel
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+  func:
+    | PikkuFunctionSessionless<void, Out, ChannelData>
+    | {
+        func: PikkuFunctionSessionless<void, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function that handles WebSocket channel disconnections.
+ * Called when a client disconnects from a channel.
+ *
+ * @template ChannelData - Type of data associated with the channel
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+  func:
+    | PikkuFunctionSessionless<void, void, ChannelData>
+    | {
+        func: PikkuFunction<void, void, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function that handles WebSocket channel messages.
+ * Called when a message is received on a channel.
+ *
+ * @template In - Input type for channel messages
+ * @template Out - Output type for channel responses
+ * @template ChannelData - Type of data associated with the channel
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out, ChannelData>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out, ChannelData>, PikkuPermission<In>>
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Registers a WebSocket channel with the Pikku framework.
+ *
+ * @template ChannelData - Type of data associated with the channel
+ * @template Channel - String literal type for the channel name
+ * @param channel - Channel definition with connection, disconnection, and message handlers
+ */
+export const wireChannel = <ChannelData, Channel extends string>(
+  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
+) => {
+  wireChannelCore(channel as any) // TODO
+}
+`;
+};

package/dist/src/{wirings → functions/wirings}/channels/serialize-typed-channel-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 serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {

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

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

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

@@ -0,0 +1,100 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { join } from 'node:path';
+import { serializeLocalCLIBootstrap } from './serialize-local-cli-bootstrap.js';
+import { serializeChannelCLI } from './serialize-channel-cli.js';
+import { serializeChannelCLIClient } from './serialize-channel-cli-client.js';
+export const pikkuCLIEntry = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        // Check if CLI entrypoints are configured
+        if (!config.cli?.entrypoints ||
+            Object.keys(config.cli.entrypoints).length === 0) {
+            logger.info({
+                message: 'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
+                type: 'skip',
+            });
+            return;
+        }
+        // Generate bootstrap files for each configured entrypoint
+        for (const [programName, entrypointConfigs] of Object.entries(config.cli.entrypoints)) {
+            const programMeta = visitState.cli.meta[programName];
+            if (!programMeta) {
+                logger.warn(`CLI program '${programName}' not found in metadata, skipping`);
+                continue;
+            }
+            // Normalize to array
+            const configs = Array.isArray(entrypointConfigs)
+                ? entrypointConfigs
+                : [entrypointConfigs];
+            for (const entrypointConfig of configs) {
+                // Normalize entrypoint config to get type
+                const entrypointType = typeof entrypointConfig === 'string'
+                    ? 'cli'
+                    : entrypointConfig.type || 'cli';
+                // Handle channel type entrypoint
+                if (entrypointType === 'channel') {
+                    if (typeof entrypointConfig === 'string' ||
+                        entrypointConfig.type !== 'channel') {
+                        throw new Error('Channel entrypoint must be a channel type object');
+                    }
+                    const channelWirePath = entrypointConfig.wirePath;
+                    const channelClientPath = entrypointConfig.path;
+                    const channelName = entrypointConfig.name;
+                    const channelRoute = entrypointConfig.route;
+                    const channelWireFile = join(config.rootDir, channelWirePath);
+                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute);
+                    await writeFileInDir(logger, channelWireFile, channelCode);
+                    logger.debug(`Serialized CLI channel for ${programName}: ${channelWireFile}`);
+                    // Generate client code if clientPath is provided
+                    if (channelClientPath) {
+                        const channelClientFile = join(config.rootDir, channelClientPath);
+                        const clientCode = serializeChannelCLIClient(programName, programMeta, channelClientFile, config, config.bootstrapFiles.cli, channelRoute);
+                        await writeFileInDir(logger, channelClientFile, clientCode);
+                        logger.debug(`Serialized CLI channel client for ${programName}: ${channelClientFile}`);
+                    }
+                    continue;
+                }
+                // Handle CLI type entrypoint (default)
+                const entrypointPath = typeof entrypointConfig === 'string'
+                    ? entrypointConfig
+                    : entrypointConfig.type === 'cli'
+                        ? entrypointConfig.path
+                        : undefined;
+                if (!entrypointPath) {
+                    throw new Error(`CLI entrypoint must have a path: ${JSON.stringify(entrypointConfig)}`);
+                }
+                const bootstrapFile = join(config.rootDir, entrypointPath);
+                // Get service factories for local mode
+                // Check for required types
+                checkRequiredTypes(visitState.filesAndMethodsErrors, {
+                    config: true,
+                    singletonServicesFactory: true,
+                    sessionServicesFactory: true,
+                });
+                const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = visitState.filesAndMethods;
+                if (!pikkuConfigFactory ||
+                    !singletonServicesFactory ||
+                    !sessionServicesFactory) {
+                    throw new Error('Required types not found');
+                }
+                const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory);
+                await writeFileInDir(logger, bootstrapFile, bootstrapCode);
+                logger.debug(`Serialized CLI bootstrap for ${programName}: ${bootstrapFile}`);
+            }
+        }
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing CLI',
+            commandEnd: 'Serialized CLI',
+            skipCondition: async ({ getInspectorState }) => {
+                const visitState = await getInspectorState();
+                return visitState.cli.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,33 @@
+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',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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,24 @@
+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',
+            skipCondition: false,
+            skipMessage: 'none found',
+        }),
+    ],
+});

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

@@ -0,0 +1,7 @@
+import { CLIProgramMeta } from '@pikku/core';
+import { Config } from '../../../../types/application-types.js';
+/**
+ * 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): string;

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

@@ -0,0 +1,54 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+/**
+ * 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) {
+    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);
+    // TODO: Collect renderer imports and create renderers map
+    // For now, renderers are not implemented
+    return `/**
+ * This file was generated by the @pikku/cli
+ */
+import { executeCLIViaChannel } from '@pikku/core/cli/channel'
+import { CorePikkuWebsocket } from '@pikku/websocket'
+import '${bootstrapImportPath}'
+
+/**
+ * ${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)
+
+  // TODO: Import and register renderers when renderer tracking is implemented
+  const renderers = {}
+
+  await executeCLIViaChannel({
+    programName: '${programName}',
+    pikkuWS,
+    args,
+    renderers,
+  })
+}
+
+// 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).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';
+/**
+ * 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,84 @@
+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 paths to type files
+    const channelTypesPath = getFileImportRelativePath(channelFile, channelTypesFile, packageMappings);
+    const functionTypesPath = getFileImportRelativePath(channelFile, functionTypesFile, packageMappings);
+    return `/**
+ * This file was generated by the @pikku/cli
+ * WebSocket channel backend for '${programName}' CLI commands
+ */
+import { wireChannel } from '${channelTypesPath}'
+import { PikkuMiddleware } from '${functionTypesPath}'
+${imports}
+
+// Middleware to close channel after command execution
+const closeAfterExecution: PikkuMiddleware = async (_services, interaction, next) => {
+  try {
+    const result = await next()
+    return result
+  } finally {
+    // Close the channel after function completes
+    if (interaction.channel) {
+      await interaction.channel.close()
+    }
+  }
+}
+
+wireChannel({
+  name: '${finalChannelName}',
+  route: '${finalChannelRoute}',
+  auth: false,
+  middleware: [closeAfterExecution],
+  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,74 @@
+/**
+ * Generates type definitions for CLI wirings
+ */
+export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * CLI-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core'
+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<any, any>> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>>
+
+/**
+ * Result type for CLI command configuration
+ */
+type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandConfig<Func>
+
+/**
+ * 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>>>, 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>>>, 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 Func - The Pikku function config type to create a CLI command for
+ * @param config - CLI command configuration
+ * @returns CLI command configuration with inferred types
+ */
+export const pikkuCLICommand = <Func extends PikkuFunctionConfig<any, any>>(
+  config: CLICommandConfig<Func>
+): CLICommandResult<Func> => {
+  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,46 @@
+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.bootstrapFiles.cli, config.packageMappings);
+    return `/**
+ * This file was generated by the @pikku/cli
+ */
+import { executeCLI } from '@pikku/core'
+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> {
+  await executeCLI({
+    programName: '${programName}',
+    args,
+    createConfig,
+    createSingletonServices,
+    createSessionServices,
+  })
+}
+
+// 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().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;