@pikku/cli 0.9.15 → 0.10.0

package/dist/bin/pikku-all.js

@@ -1,194 +0,0 @@
-import { CLILogger, getFileImportRelativePath, writeFileInDir, } from '../src/utils.js';
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js';
-import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js';
-import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js';
-import { existsSync } from 'fs';
-import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js';
-import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-import chokidar from 'chokidar';
-import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js';
-import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js';
-import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js';
-import { pikkuRPCExposedMap, pikkuRPCInternalMap, } from '../src/wirings/rpc/pikku-command-rpc-map.js';
-import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js';
-import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js';
-import { pikkuFetch } from '../src/wirings/fetch/index.js';
-import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js';
-import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
-import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
-import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js';
-import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
-import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js';
-import { pikkuSchemas } from '../src/schemas.js';
-import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js';
-import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
-const generateBootstrapFile = async (logger, cliConfig, bootstrapFile, specificImports, schemas) => {
-    // Common imports that every bootstrap file needs
-    const commonImports = [
-        cliConfig.functionsMetaMinFile,
-        cliConfig.functionsFile,
-    ];
-    // Add schema if it exists
-    if (schemas) {
-        commonImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
-    }
-    // Combine common imports with specific imports
-    const allImports = [...commonImports, ...specificImports];
-    await writeFileInDir(logger, bootstrapFile, allImports
-        .map((to) => `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`)
-        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-        .join('\n'));
-};
-const runAll = async (logger, cliConfig, options) => {
-    const allImports = [];
-    let typesDeclarationFileExists = true;
-    let visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    if (!existsSync(cliConfig.typesDeclarationFile)) {
-        typesDeclarationFileExists = false;
-    }
-    await pikkuFunctionTypes(logger, cliConfig, visitState, options);
-    // This is needed since the wireHTTP function will add the routes to the visitState
-    if (!typesDeclarationFileExists) {
-        logger.info(`• Type file first created, inspecting again...\x1b[0m`);
-        visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    }
-    const functions = pikkuFunctions(logger, cliConfig, visitState);
-    if (!functions) {
-        logger.info(`• No functions found, skipping remaining steps...\x1b[0m`);
-        process.exit(1);
-    }
-    // Base imports for all bootstrap files
-    allImports.push(cliConfig.functionsMetaFile, cliConfig.functionsFile);
-    // Generate services map
-    await pikkuServices(logger, cliConfig, visitState);
-    await pikkuRPC(logger, cliConfig, visitState);
-    await pikkuRPCInternalMap(logger, cliConfig, visitState);
-    await pikkuRPCExposedMap(logger, cliConfig, visitState);
-    await pikkuRPCClient(logger, cliConfig);
-    allImports.push(cliConfig.rpcInternalWiringMetaFile);
-    const schemas = await pikkuSchemas(logger, cliConfig, visitState);
-    if (schemas) {
-        allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
-    }
-    // RPC bootstrap is always generated since RPC is always present
-    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [], schemas);
-    const http = await pikkuHTTP(logger, cliConfig, visitState);
-    if (http) {
-        await pikkuHTTPMap(logger, cliConfig, visitState);
-        await pikkuFetch(logger, cliConfig);
-        allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile], schemas);
-    }
-    const scheduler = await pikkuScheduler(logger, cliConfig, visitState);
-    if (scheduler) {
-        allImports.push(cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile], schemas);
-    }
-    const queues = await pikkuQueue(logger, cliConfig, visitState);
-    if (queues) {
-        await pikkuQueueMap(logger, cliConfig, visitState);
-        await pikkuQueueService(logger, cliConfig);
-        allImports.push(cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile], schemas);
-    }
-    const channels = await pikkuChannels(logger, cliConfig, visitState);
-    if (channels) {
-        await pikkuChannelsMap(logger, cliConfig, visitState);
-        await pikkuWebSocketTyped(logger, cliConfig);
-        allImports.push(cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile], schemas);
-    }
-    const mcp = await pikkuMCP(logger, cliConfig, visitState);
-    if (mcp) {
-        await pikkuMCPJSON(logger, cliConfig, visitState);
-        allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile], schemas);
-    }
-    if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
-        await pikkuNext(logger, cliConfig, visitState, options);
-    }
-    if (cliConfig.openAPI) {
-        logger.info(`• OpenAPI requires a reinspection to pickup new generated types..`);
-        visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-        await pikkuOpenAPI(logger, cliConfig, visitState);
-    }
-    // Generate main bootstrap file (pass all imports directly since this is the main file)
-    await writeFileInDir(logger, cliConfig.bootstrapFile, allImports
-        .map((to) => `import '${getFileImportRelativePath(cliConfig.bootstrapFile, to, cliConfig.packageMappings)}'`)
-        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-        .join('\n'));
-};
-const watch = (logger, cliConfig, options) => {
-    const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
-        ignoreInitial: true,
-        ignored: /.*\.gen\.tsx?/,
-    });
-    let watcher = new chokidar.FSWatcher({});
-    const generatorWatcher = () => {
-        watcher.close();
-        logger.info(`• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`);
-        watcher = chokidar.watch(cliConfig.srcDirectories, {
-            ignoreInitial: true,
-            ignored: /.*\.gen\.ts/,
-        });
-        watcher.on('ready', async () => {
-            const handle = async () => {
-                try {
-                    const start = Date.now();
-                    await runAll(logger, cliConfig, options);
-                    if (options.silent) {
-                        logger.timing(`✓ Generated in ${Date.now() - start}ms`);
-                    }
-                }
-                catch (err) {
-                    console.error(err);
-                    console.info();
-                }
-            };
-            await handle();
-            let timeout;
-            const deduped = (_file) => {
-                if (timeout) {
-                    clearTimeout(timeout);
-                }
-                timeout = setTimeout(handle, 10);
-            };
-            watcher.on('change', deduped);
-            watcher.on('add', deduped);
-            watcher.on('unlink', deduped);
-        });
-    };
-    configWatcher.on('ready', generatorWatcher);
-    configWatcher.on('change', generatorWatcher);
-};
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true, silent: options.silent });
-    const cliConfig = await getPikkuCLIConfig(options.config, [], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    if (options.watch) {
-        watch(logger, cliConfig, options);
-    }
-    else {
-        await runAll(logger, cliConfig, options);
-    }
-};
-export const all = (program) => {
-    program
-        .command('all', { isDefault: true })
-        .description('Generate all the files used by pikku')
-        .option('--pikku-config-type', 'The type of your pikku config object')
-        .option('--singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('--session-services-factory-type', 'The type of your session services factory')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .option('-t | --tags <tags...>', 'Which tags to filter by')
-        .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
-        .option('--directories <directories...>', 'Which directories to filter by')
-        .option('-w | --watch', 'Whether to watch file changes')
-        .option('-s | --silent', 'Silent mode - only show errors')
-        .action(action);
-};

package/dist/bin/pikku-fetch.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const fetch: (program: Command) => void;

package/dist/bin/pikku-fetch.js

@@ -1,19 +0,0 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuFetch } from '../src/wirings/fetch/index.js';
-import { CLILogger } from '../src/utils.js';
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    await pikkuFetch(logger, cliConfig);
-};
-export const fetch = (program) => {
-    program
-        .command('fetch')
-        .description('generate fetch wrapper')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-nextjs.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const nextjs: (program: Command) => void;

package/dist/bin/pikku-nextjs.js

@@ -1,24 +0,0 @@
-import { CLILogger } from '../src/utils.js';
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuNext(logger, cliConfig, visitState, options);
-};
-export const nextjs = (program) => {
-    program
-        .command('nextjs')
-        .description('generate nextjs wrapper')
-        .option('--pikku-config-type', 'The type of your pikku config object')
-        .option('--singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('--session-services-factory-type', 'The type of your session services factory')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-openapi.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare const openapi: (program: Command) => void;

package/dist/bin/pikku-openapi.js

@@ -1,19 +0,0 @@
-import { CLILogger } from '../src/utils.js';
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
-async function action({ config, tags }) {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
-        tags: tags || [],
-    });
-    const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuOpenAPI(logger, cliConfig, visitState);
-}
-export const openapi = (program) => {
-    program
-        .command('openapi')
-        .description('Generate an openapi spec')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-queue-service.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const queue: (program: Command) => void;

package/dist/bin/pikku-queue-service.js

@@ -1,19 +0,0 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { CLILogger } from '../src/utils.js';
-import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    await pikkuQueueService(logger, cliConfig);
-};
-export const queue = (program) => {
-    program
-        .command('queue')
-        .description('generate queue service wrapper')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-rpc.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const rpc: (program: Command) => void;

package/dist/bin/pikku-rpc.js

@@ -1,19 +0,0 @@
-import { CLILogger } from '../src/utils.js';
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js';
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    await pikkuRPCClient(logger, cliConfig);
-};
-export const rpc = (program) => {
-    program
-        .command('rpc')
-        .description('generate rpc wrapper')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-schemas.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare const schemas: (program: Command) => void;

package/dist/bin/pikku-schemas.js

@@ -1,21 +0,0 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuSchemas } from '../src/schemas.js';
-import { CLILogger } from '../src/utils.js';
-async function action({ config }) {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(config, [
-        'srcDirectories',
-        'schemaDirectory',
-        'tsconfig',
-    ]);
-    const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuSchemas(logger, cliConfig, visitState);
-}
-export const schemas = (program) => {
-    program
-        .command('schemas')
-        .description('Generate schemas for all the expected function input types')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-websocket.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const websocket: (program: Command) => void;

package/dist/bin/pikku-websocket.js

@@ -1,19 +0,0 @@
-import { CLILogger } from '../src/utils.js';
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
-export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {
-        tags: options.tags,
-        types: options.types,
-        directories: options.directories,
-    }, true);
-    await pikkuWebSocketTyped(logger, cliConfig);
-};
-export const websocket = (program) => {
-    program
-        .command('websocket')
-        .description('generate websocket wrapper')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/src/inspector-glob.d.ts

@@ -1,2 +0,0 @@
-import { InspectorFilters, InspectorState } from '@pikku/inspector';
-export declare const inspectorGlob: (logger: any, rootDir: string, srcDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;

package/dist/src/inspector-glob.js

@@ -1,12 +0,0 @@
-import * as path from 'path';
-import { glob } from 'tinyglobby';
-import { inspect } from '@pikku/inspector';
-import { logCommandInfoAndTime } from './utils.js';
-export const inspectorGlob = async (logger, rootDir, srcDirectories, filters) => {
-    let result;
-    await logCommandInfoAndTime(logger, 'Inspecting codebase', 'Inspected codebase', [false], async () => {
-        const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(logger, wiringFiles, filters);
-    });
-    return result;
-};

package/dist/src/pikku-cli-config.d.ts

@@ -1,56 +0,0 @@
-import { OpenAPISpecInfo } from './wirings/http/openapi-spec-generator.js';
-import { InspectorFilters } from '@pikku/inspector';
-import { PikkuWiringTypes } from '@pikku/core';
-export interface PikkuCLICoreOutputFiles {
-    outDir?: string;
-    schemaDirectory: string;
-    typesDeclarationFile: string;
-    functionsFile: string;
-    functionsMetaFile: string;
-    functionsMetaMinFile: string;
-    httpWiringsFile: string;
-    httpWiringMetaFile: string;
-    httpMapDeclarationFile: string;
-    channelsWiringFile: string;
-    channelsWiringMetaFile: string;
-    channelsMapDeclarationFile: string;
-    rpcInternalWiringMetaFile: string;
-    rpcInternalMapDeclarationFile: string;
-    rpcMapDeclarationFile: string;
-    schedulersWiringFile: string;
-    schedulersWiringMetaFile: string;
-    queueWorkersWiringFile: string;
-    queueWorkersWiringMetaFile: string;
-    queueMapDeclarationFile: string;
-    mcpWiringsFile: string;
-    mcpWiringsMetaFile: string;
-    servicesFile: string;
-    bootstrapFile: string;
-    bootstrapFiles: Record<PikkuWiringTypes, string>;
-}
-export type PikkuCLIConfig = {
-    $schema?: string;
-    extends?: string;
-    rootDir: string;
-    srcDirectories: string[];
-    packageMappings: Record<string, string>;
-    supportsImportAttributes: boolean;
-    configDir: string;
-    tsconfig: string;
-    nextBackendFile?: string;
-    nextHTTPFile?: string;
-    fetchFile?: string;
-    websocketFile?: string;
-    rpcWiringsFile?: string;
-    queueWiringsFile?: string;
-    mcpJsonFile?: string;
-    openAPI?: {
-        outputFile: string;
-        additionalInfo: OpenAPISpecInfo;
-    };
-    middlewareServices?: string[];
-    schemasFromTypes?: string[];
-    filters: InspectorFilters;
-} & PikkuCLICoreOutputFiles;
-export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, filters?: InspectorFilters, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
-export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

package/dist/src/pikku-cli-config.js

@@ -1,203 +0,0 @@
-import { join, dirname, resolve, isAbsolute } from 'path';
-import { readdir, readFile } from 'fs/promises';
-import { PikkuWiringTypes } from '@pikku/core';
-const CONFIG_DIR_FILES = [
-    'nextBackendFile',
-    'nextHTTPFile',
-    'fetchFile',
-    'websocketFile',
-    'rpcWiringsFile',
-    'queueWiringsFile',
-    'mcpJsonFile',
-];
-export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
-    const config = await _getPikkuCLIConfig(configFile, requiredFields, filters, exitProcess);
-    return config;
-};
-const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
-    if (!configFile) {
-        let execDirectory = process.cwd();
-        const files = await readdir(execDirectory);
-        const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file));
-        if (!file) {
-            const errorMessage = '\nConfig file pikku.config.json not found\nExiting...';
-            if (exitProcess) {
-                console.error(errorMessage);
-                process.exit(1);
-            }
-            throw new Error(errorMessage);
-        }
-        configFile = join(execDirectory, file);
-    }
-    try {
-        let result;
-        const file = await readFile(configFile, 'utf-8');
-        const configDir = dirname(configFile);
-        const config = JSON.parse(file);
-        if (config.extends) {
-            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], filters, exitProcess);
-            result = {
-                ...extendedConfig,
-                ...config,
-                configDir,
-                packageMappings: {
-                    ...extendedConfig.packageMappings,
-                    ...config.packageMappings,
-                },
-            };
-        }
-        else {
-            result = {
-                ...config,
-                configDir,
-                packageMappings: config.packageMappings || {},
-                rootDir: config.rootDir
-                    ? resolve(configDir, config.rootDir)
-                    : configDir,
-            };
-        }
-        if (result.outDir) {
-            // Create transport/event directories
-            const functionDir = join(result.outDir, 'function');
-            const httpDir = join(result.outDir, 'http');
-            const channelDir = join(result.outDir, 'channel');
-            const rpcDir = join(result.outDir, 'rpc');
-            const schedulerDir = join(result.outDir, 'scheduler');
-            const queueDir = join(result.outDir, 'queue');
-            const mcpDir = join(result.outDir, 'mcp');
-            // Create directories if they don't exist (will be done lazily when files are written)
-            if (!result.schemaDirectory) {
-                result.schemaDirectory = join(result.outDir, 'schemas');
-            }
-            // Functions
-            if (!result.functionsFile) {
-                result.functionsFile = join(functionDir, 'pikku-functions.gen.ts');
-            }
-            if (!result.functionsMetaFile) {
-                result.functionsMetaFile = join(functionDir, 'pikku-functions-meta.gen.ts');
-            }
-            if (!result.functionsMetaMinFile) {
-                result.functionsMetaMinFile = join(functionDir, 'pikku-functions-meta.min.gen.ts');
-            }
-            if (!result.typesDeclarationFile) {
-                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
-            }
-            // HTTP
-            if (!result.httpWiringsFile) {
-                result.httpWiringsFile = join(httpDir, 'pikku-http-wirings.gen.ts');
-            }
-            if (!result.httpWiringMetaFile) {
-                result.httpWiringMetaFile = join(httpDir, 'pikku-http-wirings-meta.gen.ts');
-            }
-            if (!result.httpMapDeclarationFile) {
-                result.httpMapDeclarationFile = join(httpDir, 'pikku-http-wirings-map.gen.d.ts');
-            }
-            // Channels/WebSocket
-            if (!result.channelsWiringFile) {
-                result.channelsWiringFile = join(channelDir, 'pikku-channels.gen.ts');
-            }
-            if (!result.channelsWiringMetaFile) {
-                result.channelsWiringMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts');
-            }
-            if (!result.channelsMapDeclarationFile) {
-                result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
-            }
-            // RPC (internal and exposed)
-            if (!result.rpcInternalWiringMetaFile) {
-                result.rpcInternalWiringMetaFile = join(rpcDir, 'pikku-rpc-wirings-meta.internal.gen.ts');
-            }
-            if (!result.rpcInternalMapDeclarationFile) {
-                result.rpcInternalMapDeclarationFile = join(rpcDir, 'pikku-rpc-wirings-map.internal.gen.d.ts');
-            }
-            if (!result.rpcMapDeclarationFile) {
-                result.rpcMapDeclarationFile = join(rpcDir, 'pikku-rpc-wirings-map.gen.d.ts');
-            }
-            // Scheduler
-            if (!result.schedulersWiringFile) {
-                result.schedulersWiringFile = join(schedulerDir, 'pikku-schedulers-wirings.gen.ts');
-            }
-            if (!result.schedulersWiringMetaFile) {
-                result.schedulersWiringMetaFile = join(schedulerDir, 'pikku-schedulers-wirings-meta.gen.ts');
-            }
-            // Queue
-            if (!result.queueWorkersWiringFile) {
-                result.queueWorkersWiringFile = join(queueDir, 'pikku-queue-workers-wirings.gen.ts');
-            }
-            if (!result.queueWorkersWiringMetaFile) {
-                result.queueWorkersWiringMetaFile = join(queueDir, 'pikku-queue-workers-wirings-meta.gen.ts');
-            }
-            if (!result.queueMapDeclarationFile) {
-                result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-workers-wirings-map.gen.d.ts');
-            }
-            // Services
-            if (!result.servicesFile) {
-                result.servicesFile = join(result.outDir, 'pikku-services.gen.ts');
-            }
-            // Bootstrap files
-            if (!result.bootstrapFile) {
-                result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
-            }
-            // MCP
-            if (!result.mcpWiringsMetaFile) {
-                result.mcpWiringsMetaFile = join(mcpDir, 'pikku-mcp-wirings-meta.gen.ts');
-            }
-            if (!result.mcpWiringsFile) {
-                result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts');
-            }
-            if (!result.mcpJsonFile) {
-                result.mcpJsonFile = join(mcpDir, 'pikku-mcp.gen.json');
-            }
-            result.bootstrapFiles = result.bootstrapFiles || {};
-            for (const key of Object.keys(PikkuWiringTypes)) {
-                const eventDir = join(result.outDir, key.toLowerCase());
-                result.bootstrapFiles[key] = join(eventDir, `pikku-bootstrap-${key}.gen.ts`);
-            }
-        }
-        if (requiredFields.length > 0) {
-            validateCLIConfig(result, requiredFields);
-        }
-        for (const objectKey of Object.keys(result)) {
-            if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
-                const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
-                    ? result.configDir
-                    : result.rootDir;
-                if (result[objectKey]) {
-                    if (!isAbsolute(result[objectKey])) {
-                        result[objectKey] = join(relativeTo, result[objectKey]);
-                    }
-                }
-            }
-        }
-        result.filters = result.filters || {};
-        if (filters.tags && filters.tags.length > 0) {
-            result.filters.tags = filters.tags;
-        }
-        if (filters.types && filters.types.length > 0) {
-            result.filters.types = filters.types;
-        }
-        if (filters.directories && filters.directories.length > 0) {
-            result.filters.directories = filters.directories;
-        }
-        if (!isAbsolute(result.tsconfig)) {
-            result.tsconfig = join(result.rootDir, result.tsconfig);
-        }
-        return result;
-    }
-    catch (e) {
-        console.error(e);
-        console.error(`Config file not found: ${configFile}`);
-        process.exit(1);
-    }
-};
-export const validateCLIConfig = (cliConfig, required) => {
-    let errors = [];
-    for (const key of required) {
-        if (!cliConfig[key]) {
-            errors.push(key);
-        }
-    }
-    if (errors.length > 0) {
-        console.error(`${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`);
-        process.exit(1);
-    }
-};