@pikku/cli 0.9.14 → 0.9.16-next.0

package/dist/src/services/cli-logger.service.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import { LogLevel } from '@pikku/core';
+const logo = `
+ ______ _ _     _
+(_____ (_) |   | |
+ _____) )| |  _| |  _ _   _
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (|  _ (| |_| |
+|_|    |_|_| _)_| _)____/
+`;
+export class CLILogger {
+    silent;
+    level = LogLevel.info;
+    constructor({ logLogo, silent = false, }) {
+        this.silent = silent;
+        if (logLogo && !silent) {
+            this.logPikkuLogo();
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    info(message) {
+        if (this.level > LogLevel.info || this.silent)
+            return;
+        let c = chalk.blue;
+        if (typeof message === 'object') {
+            if (message.type === 'success') {
+                c = chalk.green;
+            }
+            else if (message.type === 'timing') {
+                c = chalk.gray;
+            }
+        }
+        console.log(c(typeof message === 'string' ? message : message.message));
+    }
+    error(message) {
+        if (this.level > LogLevel.error)
+            return;
+        console.error(chalk.red(message));
+    }
+    warn(message) {
+        if (this.level > LogLevel.warn)
+            return;
+        console.error(chalk.yellow(message));
+    }
+    debug(message) {
+        if (this.level > LogLevel.debug || this.silent)
+            return;
+        console.log(chalk.gray(message));
+    }
+    logPikkuLogo() {
+        this.primary(logo);
+        // // When running from dist/, __filename is dist/src/services/cli-logger.service.js
+        // // So we need to go up 3 levels: dist/src/services -> dist/src -> dist -> package.json
+        // const packageJson = JSON.parse(
+        //   readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
+        // )
+        // this.primary(`⚙️  Welcome to the Pikku CLI (v${packageJson.version})\n`)
+    }
+    primary(message) {
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
+    }
+}

package/dist/src/services.d.ts

@@ -0,0 +1,15 @@
+import type { Config, Services, SingletonServices, UserSession } from '../types/application-types.js';
+import { CreateConfig, CreateSessionServices, CreateSingletonServices } from '@pikku/core';
+import { PikkuCLIConfig } from '../types/config.js';
+import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js';
+/**
+ * Default CLI renderer that logs output using the logger
+ */
+export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
+export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
+/**
+ * Singleton services factory for the Pikku CLI
+ * This function creates the singleton services used by the CLI and is created once on start.
+ */
+export declare const createSingletonServices: CreateSingletonServices<Config, SingletonServices>;
+export declare const createSessionServices: CreateSessionServices<SingletonServices, Services, UserSession>;

package/dist/src/services.js

@@ -0,0 +1,64 @@
+import { pikkuCLIRender, } from '@pikku/core';
+import { LocalVariablesService } from '@pikku/core/services';
+import { CLILogger } from './services/cli-logger.service.js';
+import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
+import { inspect } from '@pikku/inspector';
+import { glob } from 'tinyglobby';
+import path from 'path';
+import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+const logger = new CLILogger({ logLogo: true, silent: false });
+/**
+ * Default CLI renderer that logs output using the logger
+ */
+export const defaultCLIRenderer = pikkuCLIRender((_services, data) => {
+    if (data) {
+        logger[data.level]({ message: data.message, type: data.type });
+    }
+});
+export const createConfig = async (_variablesService, data) => {
+    const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], data, true);
+    return {
+        ...cliConfig,
+        ...data,
+    };
+};
+/**
+ * Singleton services factory for the Pikku CLI
+ * This function creates the singleton services used by the CLI and is created once on start.
+ */
+export const createSingletonServices = async (config) => {
+    const { rootDir, srcDirectories, filters } = config;
+    const variables = new LocalVariablesService();
+    let inspectorState = undefined;
+    const getInspectorState = async (refresh = false) => {
+        if (refresh || !inspectorState) {
+            const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
+            inspectorState = await inspect(logger, wiringFiles, {
+                filters,
+                types: {
+                    configFileType: config.configFile,
+                    userSessionType: config.tags?.[0], // TODO: Properly handle type selection
+                    singletonServicesFactoryType: undefined,
+                    sessionServicesFactoryType: undefined,
+                },
+            });
+            return inspectorState;
+        }
+        return inspectorState;
+    };
+    return {
+        config,
+        logger,
+        variables,
+        getInspectorState,
+    };
+};
+export const createSessionServices = async ({ logger }, { cli, channel }) => {
+    const vChannel = cli ? cli.channel : channel;
+    if (!vChannel) {
+        throw new Error('No channel provided for CLI services');
+    }
+    return {
+        logger: new CLILoggerForwarder(logger, vChannel),
+    };
+};

package/dist/src/utils/check-required-types.d.ts

@@ -0,0 +1,10 @@
+import { FilesAndMethodsErrors } from '@pikku/inspector';
+export type RequiredTypes = Partial<{
+    config: boolean;
+    sessionServiceType: boolean;
+    singletonServicesType: boolean;
+    userSessionType: boolean;
+    singletonServicesFactory: boolean;
+    sessionServicesFactory: boolean;
+}>;
+export declare const checkRequiredTypes: (errors: FilesAndMethodsErrors, requires?: RequiredTypes) => void;

package/dist/src/utils/check-required-types.js

@@ -0,0 +1,31 @@
+export const checkRequiredTypes = (errors, requires = {}) => {
+    // Only throw if there are errors AND we require those types
+    const hasRequiredErrors = Array.from(errors.keys()).some((message) => {
+        if (requires.config && message.includes('CoreConfig'))
+            return true;
+        if (requires.sessionServiceType && message.includes('CoreServices'))
+            return true;
+        if (requires.singletonServicesType &&
+            message.includes('CoreSingletonServices'))
+            return true;
+        if (requires.userSessionType && message.includes('CoreUserSession'))
+            return true;
+        if (requires.singletonServicesFactory &&
+            message.includes('CreateSingletonServices'))
+            return true;
+        if (requires.sessionServicesFactory &&
+            message.includes('CreateSessionServices'))
+            return true;
+        return false;
+    });
+    if (hasRequiredErrors) {
+        const result = ['Found errors:'];
+        errors.forEach((filesAndMethods, message) => {
+            result.push(`- ${message}`);
+            filesAndMethods.forEach((methods, file) => {
+                result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
+            });
+        });
+        throw new Error(result.join('\n'));
+    }
+};

package/dist/src/utils/custom-types-generator.d.ts

@@ -0,0 +1,2 @@
+import { TypesMap } from '@pikku/inspector';
+export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/utils/custom-types-generator.js

@@ -0,0 +1,37 @@
+export function generateCustomTypes(typesMap, requiredTypes) {
+    return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+        .map(([name, { type, references }]) => {
+        references.forEach((name) => {
+            requiredTypes.add(name);
+        });
+        // Extract type names from the type string that might not be in references
+        const typeString = type;
+        // Use regex to extract potential type names (PascalCase identifiers)
+        const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
+        const potentialTypes = typeString.match(typeNameRegex) || [];
+        potentialTypes.forEach((typeName) => {
+            // Skip string literals and common keywords
+            if (typeString.includes(`"${typeName}"`) ||
+                ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(typeName)) {
+                return;
+            }
+            // Try to find this type in the typesMap and add it if found
+            try {
+                const typeMeta = typesMap.getTypeMeta(typeName);
+                if (typeMeta.path) {
+                    // Add originalName to preserve canonical import name
+                    requiredTypes.add(typeMeta.originalName);
+                }
+            }
+            catch (e) {
+                // Type not found in map (ambient/builtin type) - ignore it
+                // Do NOT add to requiredTypes to avoid crashes in serializeImportMap
+            }
+        });
+        return `export type ${name} = ${type}`;
+    })
+        .join('\n')}`;
+}

package/dist/src/utils/file-import-path.d.ts

@@ -0,0 +1 @@
+export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;

package/dist/src/utils/file-import-path.js

@@ -0,0 +1,43 @@
+import { relative, dirname, resolve } from 'path';
+export const getFileImportRelativePath = (from, to, packageMappings) => {
+    let filePath = relative(dirname(from), to);
+    if (!/^\.+\//.test(filePath)) {
+        filePath = `./${filePath}`;
+    }
+    // If the path includes node_modules, strip everything before and including node_modules/
+    if (filePath.includes('node_modules')) {
+        const nodeModulesIndex = filePath.indexOf('node_modules/');
+        if (nodeModulesIndex !== -1) {
+            filePath = filePath.substring(nodeModulesIndex + 'node_modules/'.length);
+        }
+        return filePath.replace('.ts', '.js');
+    }
+    const absolutePath = resolve(dirname(from), to);
+    const fromAbsolutePath = resolve(dirname(from));
+    // Check if both files are in the same package directory
+    // If so, skip packageMappings to use relative paths
+    let inSamePackage = false;
+    for (const [path] of Object.entries(packageMappings)) {
+        if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
+            inSamePackage = true;
+            break;
+        }
+    }
+    // Only apply packageMappings if files are not in the same package
+    if (!inSamePackage) {
+        // let usesPackageName = false
+        for (const [path, packageName] of Object.entries(packageMappings)) {
+            if (absolutePath.includes(path)) {
+                // usesPackageName = true
+                // Use string slicing instead of regex to avoid ReDoS and ensure correct behavior
+                const pathIndex = absolutePath.indexOf(path);
+                filePath = packageName + absolutePath.slice(pathIndex + path.length);
+                break;
+            }
+        }
+    }
+    // if (usesPackageName) {
+    //   return filePath.replace('.ts', '')
+    // }
+    return filePath.replace('.ts', '.js');
+};

package/dist/src/utils/file-imports-serializer.d.ts

@@ -0,0 +1 @@
+export declare const serializeFileImports: (importType: string, outputPath: string, files: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/utils/file-imports-serializer.js

@@ -0,0 +1,13 @@
+import { getFileImportRelativePath } from './file-import-path.js';
+export const serializeFileImports = (importType, outputPath, files, packageMappings = {}) => {
+    const serializedOutput = [
+        `/* The files with an ${importType} function call */`,
+    ];
+    Array.from(files)
+        .sort()
+        .forEach((path) => {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        serializedOutput.push(`import '${filePath}'`);
+    });
+    return serializedOutput.join('\n');
+};

package/dist/src/utils/file-writer.d.ts

@@ -0,0 +1,6 @@
+import { CLILogger } from '../services/cli-logger.service.js';
+export declare const DO_NOT_MODIFY_COMMENT = "/**\n * This file was generated by the @pikku/cli\n */\n";
+export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
+    ignoreModifyComment?: boolean;
+    logWrite?: boolean;
+}) => Promise<void>;

package/dist/src/utils/file-writer.js

@@ -0,0 +1,40 @@
+import { dirname } from 'path';
+import { mkdir, readFile, writeFile } from 'fs/promises';
+// TODO: add version back in once the ESM dust settles
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by the @pikku/cli
+ */
+`;
+export const writeFileInDir = async (logger, path, content, { ignoreModifyComment = false, logWrite = true, } = {}) => {
+    if (path.includes('.json')) {
+        ignoreModifyComment = true;
+    }
+    if (content.includes('server-only')) {
+        content = content.replace("'server-only'", `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`);
+    }
+    else {
+        content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`;
+    }
+    // Try to read existing file content
+    let existingContent;
+    try {
+        existingContent = await readFile(path, 'utf-8');
+    }
+    catch (error) {
+        // Only suppress ENOENT (file not found) errors
+        // Rethrow permission, I/O, encoding, or other errors
+        const nodeError = error;
+        if (nodeError.code !== 'ENOENT') {
+            throw error;
+        }
+        // File doesn't exist, so we need to write it
+    }
+    // Only write if content has changed or file doesn't exist
+    if (existingContent !== content) {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, content, 'utf-8');
+        if (logWrite) {
+            logger.info({ message: `✓ File written to ${path}`, type: 'success' });
+        }
+    }
+};

package/dist/src/utils/generate-bootstrap-file.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../../types/application-types.js';
+import { CLILogger } from '../services/cli-logger.service.js';
+export declare const generateBootstrapFile: (logger: CLILogger, config: Config, bootstrapFile: string, specificImports: string[], schemas?: boolean, hasMiddleware?: boolean) => Promise<void>;

package/dist/src/utils/generate-bootstrap-file.js

@@ -0,0 +1,21 @@
+import { getFileImportRelativePath } from './file-import-path.js';
+import { writeFileInDir } from './file-writer.js';
+export const generateBootstrapFile = async (logger, config, bootstrapFile, specificImports, schemas, hasMiddleware) => {
+    // Common imports that every bootstrap file needs
+    const commonImports = [];
+    // Add middleware first (must be registered before functions meta)
+    if (hasMiddleware) {
+        commonImports.push(config.middlewareFile);
+    }
+    commonImports.push(config.functionsMetaMinFile, config.functionsFile);
+    // Add schema if it exists
+    if (schemas) {
+        commonImports.push(`${config.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, config.packageMappings)}'`)
+        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+        .join('\n'));
+};

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

@@ -0,0 +1,5 @@
+import { PikkuCLIConfig } from '../../types/config.js';
+import { InspectorFilters } from '@pikku/inspector';
+import { CLILogger } from '../services/cli-logger.service.js';
+export declare const getPikkuCLIConfig: (logger: CLILogger, 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/utils/pikku-cli-config.js

@@ -0,0 +1,243 @@
+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 (logger, configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(logger, configFile, requiredFields, filters, exitProcess);
+    return config;
+};
+const _getPikkuCLIConfig = async (logger, 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) {
+            throw new Error('Config file pikku.config.json not found');
+        }
+        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(logger, 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,
+            };
+        }
+        // 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');
+        const cliDir = join(result.outDir, 'cli');
+        const middlewareDir = join(result.outDir, 'middleware');
+        // 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.functionTypesFile) {
+            result.functionTypesFile = join(functionDir, 'pikku-function-types.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');
+        }
+        if (!result.httpTypesFile) {
+            result.httpTypesFile = join(httpDir, 'pikku-http-types.gen.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');
+        }
+        if (!result.channelsTypesFile) {
+            result.channelsTypesFile = join(channelDir, 'pikku-channel-types.gen.ts');
+        }
+        // RPC (internal and external)
+        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');
+        }
+        if (!result.schedulersTypesFile) {
+            result.schedulersTypesFile = join(schedulerDir, 'pikku-scheduler-types.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');
+        }
+        if (!result.queueTypesFile) {
+            result.queueTypesFile = join(queueDir, 'pikku-queue-types.gen.ts');
+        }
+        // Services
+        if (!result.servicesFile) {
+            result.servicesFile = join(result.outDir, 'pikku-services.gen.ts');
+        }
+        // Middleware
+        if (!result.middlewareFile) {
+            result.middlewareFile = join(middlewareDir, 'pikku-middleware.gen.ts');
+        }
+        if (!result.middlewareGroupsMetaFile) {
+            result.middlewareGroupsMetaFile = join(middlewareDir, 'pikku-middleware-groups-meta.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');
+        }
+        if (!result.mcpTypesFile) {
+            result.mcpTypesFile = join(mcpDir, 'pikku-mcp-types.gen.ts');
+        }
+        // CLI
+        if (!result.cliWiringsFile) {
+            result.cliWiringsFile = join(cliDir, 'pikku-cli-wirings.gen.ts');
+        }
+        if (!result.cliWiringMetaFile) {
+            result.cliWiringMetaFile = join(cliDir, 'pikku-cli-wirings-meta.gen.ts');
+        }
+        if (!result.cliBootstrapFile) {
+            result.cliBootstrapFile = join(cliDir, 'pikku-cli-bootstrap.gen.ts');
+        }
+        if (!result.cliTypesFile) {
+            result.cliTypesFile = join(cliDir, 'pikku-cli-types.gen.ts');
+        }
+        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;
+                // Only normalize string values to avoid corrupting nested objects
+                if (result[objectKey] && typeof result[objectKey] === 'string') {
+                    if (!isAbsolute(result[objectKey])) {
+                        result[objectKey] = join(relativeTo, result[objectKey]);
+                    }
+                }
+            }
+        }
+        // Separately normalize bootstrapFiles (Record<string, string>)
+        if (result.bootstrapFiles && typeof result.bootstrapFiles === 'object') {
+            for (const [key, value] of Object.entries(result.bootstrapFiles)) {
+                if (typeof value === 'string' && !isAbsolute(value)) {
+                    result.bootstrapFiles[key] = join(result.rootDir, value);
+                }
+            }
+        }
+        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) {
+        logger.error(e);
+        throw new Error(`Config file not found: ${configFile}`);
+    }
+};
+export const validateCLIConfig = (cliConfig, required) => {
+    let errors = [];
+    for (const key of required) {
+        if (!cliConfig[key]) {
+            errors.push(key);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`);
+    }
+};

package/dist/src/utils/pikku-files-and-methods.d.ts

@@ -0,0 +1,21 @@
+import { InspectorState, InspectorOptions } from '@pikku/inspector';
+interface Meta {
+    file: string;
+    variable: string;
+    type: string;
+    typePath: string;
+    errors: Map<string, string[]>;
+}
+export type FilesAndMethods = {
+    userSessionType: Meta;
+    sessionServicesType: Meta;
+    singletonServicesType: Meta;
+    pikkuConfigFactory: Meta;
+    singletonServicesFactory: Meta;
+    sessionServicesFactory: Meta;
+};
+/**
+ * @deprecated Use state.filesAndMethods from InspectorState instead
+ */
+export declare const getPikkuFilesAndMethods: (state: InspectorState, options?: InspectorOptions["types"]) => Promise<FilesAndMethods>;
+export {};