@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,224 @@
+import { join, dirname, resolve, isAbsolute } from 'path';
+import { readdir, readFile } from 'fs/promises';
+const CONFIG_DIR_FILES = [
+    'nextBackendFile',
+    'nextHTTPFile',
+    'fetchFile',
+    'websocketFile',
+    'rpcWiringsFile',
+    'queueWiringsFile',
+    'mcpJsonFile',
+];
+export const getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields, exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(logger, configFile, requiredFields, exitProcess);
+    return config;
+};
+const _getPikkuCLIConfig = async (logger, configFile = undefined, requiredFields, 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), [], 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');
+        }
+        // Permissions
+        const permissionsDir = join(result.outDir, 'permissions');
+        if (!result.permissionsFile) {
+            result.permissionsFile = join(permissionsDir, 'pikku-permissions.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');
+        }
+        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]);
+                    }
+                }
+            }
+        }
+        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 {};

package/dist/src/utils/pikku-files-and-methods.js

@@ -0,0 +1,70 @@
+const getMetaTypes = (type, map, desiredType) => {
+    const errors = new Map();
+    if (desiredType) {
+        for (const [file, meta] of map.entries()) {
+            for (const { type: entryType, variable, typePath } of meta) {
+                if (entryType === desiredType) {
+                    if (entryType === null || typePath === null) {
+                        throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${desiredType} in ${file}`);
+                    }
+                    return { file, variable, type: entryType, typePath, errors };
+                }
+            }
+        }
+        errors.set(`No ${desiredType} found that extends ${type}`, map);
+        return;
+    }
+    const totalValues = Array.from(map.values()).flat();
+    if (totalValues.length === 0) {
+        const helpMessage = type === 'CoreConfig'
+            ? `No ${type} found. Make sure you have exported a createConfig function in your codebase:\n\n` +
+                `export const createConfig: CreateConfig<Config> = async () => {\n` +
+                `  return {}\n` +
+                `}\n\n` +
+                `Possible issues:\n` +
+                `- srcDirectories in pikku.config.json doesn't include the file with the createConfig method`
+            : `No ${type} found`;
+        errors.set(helpMessage, map);
+    }
+    else if (totalValues.length > 1) {
+        errors.set(`More than one ${type} found`, map);
+    }
+    else {
+        const entry = Array.from(map.entries())[0];
+        if (entry) {
+            const [file, [{ type: entryType, variable, typePath }]] = entry;
+            if (entryType === null || typePath === null) {
+                throw new Error(`Unknown state due to metaType calculation: entryType or typePath is null for ${type} in ${file}`);
+            }
+            return { file, type: entryType, variable, typePath, errors };
+        }
+    }
+    return;
+};
+/**
+ * @deprecated Use state.filesAndMethods from InspectorState instead
+ */
+export const getPikkuFilesAndMethods = async (state, options = {}) => {
+    const { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, } = state;
+    const { configFileType, userSessionType, singletonServicesFactoryType, sessionServicesFactoryType, } = options;
+    let errors = new Map();
+    const result = {
+        userSessionType: getMetaTypes('CoreUserSession', userSessionTypeImportMap, userSessionType),
+        singletonServicesType: getMetaTypes('CoreSingletonServices', singletonServicesTypeImportMap),
+        sessionServicesType: getMetaTypes('CoreServices', sessionServicesTypeImportMap),
+        pikkuConfigFactory: getMetaTypes('CoreConfig', configFactories, configFileType),
+        singletonServicesFactory: getMetaTypes('CreateSingletonServices', singletonServicesFactories, singletonServicesFactoryType),
+        sessionServicesFactory: getMetaTypes('CreateSessionServices', sessionServicesFactories, sessionServicesFactoryType),
+    };
+    if (errors.size > 0) {
+        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'));
+    }
+    return result;
+};

package/dist/src/{schema-generator.d.ts → utils/schema-generator.d.ts}

@@ -1,6 +1,6 @@
-import { CLILogger } from './utils.js';
 import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
+import { CLILogger } from '../services/cli-logger.service.js';
 export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[]): Promise<Record<string, JSONValue>>;
 export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[]): Promise<void>;

package/dist/src/{schema-generator.js → utils/schema-generator.js}

@@ -1,6 +1,7 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { writeFileInDir } from './utils.js';
+import { writeFileInDir } from './file-writer.js';
 import { mkdir, writeFile } from 'fs/promises';
+import { ErrorCode } from '@pikku/inspector';
 export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta, additionalTypes) {
     const schemasSet = new Set(typesMap.customTypes.keys());
     for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -51,10 +52,10 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
         catch (e) {
             // Ignore rootless errors
             if (e instanceof RootlessError) {
-                logger.error(`Error generating schema since it has no root: ${schema}`);
+                logger.error(`[${ErrorCode.SCHEMA_NO_ROOT}] Error generating schema since it has no root: ${schema}`);
                 return;
             }
-            logger.error(`Error generating schema: ${schema}`);
+            logger.error(`[${ErrorCode.SCHEMA_GENERATION_ERROR}] Error generating schema: ${schema}. Message: ${e.message}`);
         }
     });
     return schemas;

package/dist/src/{serialize-import-map.js → utils/serialize-import-map.js}

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath } from './utils.js';
+import { getFileImportRelativePath } from './file-import-path.js';
 export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
     const paths = new Map();
     Array.from(requiredTypes).forEach((requiredType) => {
@@ -69,9 +69,6 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
             return;
         }
         const variables = paths.get(path) || [];
-        if (uniqueName === '__object') {
-            return;
-        }
         const importName = originalName === uniqueName
             ? originalName
             : `${originalName} as ${uniqueName}`;

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-rpc.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/wirings/channels/pikku-channels.ts","../src/wirings/channels/pikku-command-channels-map.ts","../src/wirings/channels/pikku-command-channels.ts","../src/wirings/channels/pikku-command-websocket-typed.ts","../src/wirings/channels/serialize-typed-channel-map.ts","../src/wirings/channels/serialize-websocket-wrapper.ts","../src/wirings/fetch/index.ts","../src/wirings/functions/pikku-command-function-types.ts","../src/wirings/functions/pikku-command-functions.ts","../src/wirings/functions/pikku-command-services.ts","../src/wirings/functions/pikku-function-types.ts","../src/wirings/functions/serialize-function-imports.ts","../src/wirings/http/openapi-spec-generator.ts","../src/wirings/http/pikku-command-http-map.ts","../src/wirings/http/pikku-command-http-routes.ts","../src/wirings/http/pikku-command-openapi.ts","../src/wirings/http/pikku-http-routes.ts","../src/wirings/http/serialize-fetch-wrapper.ts","../src/wirings/http/serialize-typed-http-map.ts","../src/wirings/mcp/pikku-command-mcp-json.ts","../src/wirings/mcp/pikku-command-mcp.ts","../src/wirings/mcp/serialize-mcp-json.ts","../src/wirings/queue/pikku-command-queue-map.ts","../src/wirings/queue/pikku-command-queue-service.ts","../src/wirings/queue/pikku-command-queue.ts","../src/wirings/queue/pikku-queue-map.ts","../src/wirings/queue/pikku-queue.ts","../src/wirings/queue/serialize-queue-map.ts","../src/wirings/queue/serialize-queue-meta.ts","../src/wirings/queue/serialize-queue-wrapper.ts","../src/wirings/rpc/pikku-command-rpc-client.ts","../src/wirings/rpc/pikku-command-rpc-map.ts","../src/wirings/rpc/pikku-command-rpc.ts","../src/wirings/rpc/serialize-rpc-wrapper.ts","../src/wirings/rpc/serialize-typed-rpc-map.ts","../src/wirings/scheduler/pikku-command-scheduler.ts","../src/wirings/scheduler/serialize-scheduler-meta.ts"],"version":"5.9.2"}
+{"root":["../bin/pikku.ts","../src/cli.wiring.ts","../src/services.ts","../src/functions/commands/all.ts","../src/functions/commands/watch.ts","../src/functions/runtimes/nextjs/pikku-command-nextjs.ts","../src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/functions/wirings/channels/pikku-channels.ts","../src/functions/wirings/channels/pikku-command-channel-types.ts","../src/functions/wirings/channels/pikku-command-channels-map.ts","../src/functions/wirings/channels/pikku-command-channels.ts","../src/functions/wirings/channels/pikku-command-websocket-typed.ts","../src/functions/wirings/channels/serialize-channel-types.ts","../src/functions/wirings/channels/serialize-typed-channel-map.ts","../src/functions/wirings/channels/serialize-websocket-wrapper.ts","../src/functions/wirings/cli/pikku-command-cli-entry.ts","../src/functions/wirings/cli/pikku-command-cli-types.ts","../src/functions/wirings/cli/pikku-command-cli.ts","../src/functions/wirings/cli/serialize-channel-cli-client.ts","../src/functions/wirings/cli/serialize-channel-cli.ts","../src/functions/wirings/cli/serialize-cli-types.ts","../src/functions/wirings/cli/serialize-local-cli-bootstrap.ts","../src/functions/wirings/fetch/index.ts","../src/functions/wirings/functions/pikku-command-function-types-split.ts","../src/functions/wirings/functions/pikku-command-function-types.ts","../src/functions/wirings/functions/pikku-command-functions.ts","../src/functions/wirings/functions/pikku-command-services.ts","../src/functions/wirings/functions/pikku-function-types.ts","../src/functions/wirings/functions/schemas.ts","../src/functions/wirings/functions/serialize-function-imports.ts","../src/functions/wirings/functions/serialize-function-types.ts","../src/functions/wirings/functions/serialize-pikku-types-hub.ts","../src/functions/wirings/http/openapi-spec-generator.ts","../src/functions/wirings/http/pikku-command-http-map.ts","../src/functions/wirings/http/pikku-command-http-routes.ts","../src/functions/wirings/http/pikku-command-http-types.ts","../src/functions/wirings/http/pikku-command-openapi.ts","../src/functions/wirings/http/pikku-http-routes.ts","../src/functions/wirings/http/serialize-fetch-wrapper.ts","../src/functions/wirings/http/serialize-http-types.ts","../src/functions/wirings/http/serialize-typed-http-map.ts","../src/functions/wirings/mcp/pikku-command-mcp-json.ts","../src/functions/wirings/mcp/pikku-command-mcp-types.ts","../src/functions/wirings/mcp/pikku-command-mcp.ts","../src/functions/wirings/mcp/serialize-mcp-json.ts","../src/functions/wirings/mcp/serialize-mcp-types.ts","../src/functions/wirings/middleware/pikku-command-middleware.ts","../src/functions/wirings/middleware/serialize-middleware-groups-meta.ts","../src/functions/wirings/middleware/serialize-middleware-imports.ts","../src/functions/wirings/permissions/pikku-command-permissions.ts","../src/functions/wirings/permissions/serialize-permissions-imports.ts","../src/functions/wirings/queue/pikku-command-queue-map.ts","../src/functions/wirings/queue/pikku-command-queue-service.ts","../src/functions/wirings/queue/pikku-command-queue-types.ts","../src/functions/wirings/queue/pikku-command-queue.ts","../src/functions/wirings/queue/pikku-queue-map.ts","../src/functions/wirings/queue/pikku-queue.ts","../src/functions/wirings/queue/serialize-queue-map.ts","../src/functions/wirings/queue/serialize-queue-meta.ts","../src/functions/wirings/queue/serialize-queue-types.ts","../src/functions/wirings/queue/serialize-queue-wrapper.ts","../src/functions/wirings/rpc/pikku-command-rpc-client.ts","../src/functions/wirings/rpc/pikku-command-rpc-map.ts","../src/functions/wirings/rpc/pikku-command-rpc.ts","../src/functions/wirings/rpc/serialize-rpc-wrapper.ts","../src/functions/wirings/rpc/serialize-typed-rpc-map.ts","../src/functions/wirings/scheduler/pikku-command-scheduler-types.ts","../src/functions/wirings/scheduler/pikku-command-scheduler.ts","../src/functions/wirings/scheduler/serialize-scheduler-meta.ts","../src/functions/wirings/scheduler/serialize-scheduler-types.ts","../src/middleware/log-command-info-and-time.ts","../src/services/cli-logger-forwarder.service.ts","../src/services/cli-logger.service.ts","../src/utils/check-required-types.ts","../src/utils/custom-types-generator.ts","../src/utils/file-import-path.ts","../src/utils/file-imports-serializer.ts","../src/utils/file-writer.ts","../src/utils/generate-bootstrap-file.ts","../src/utils/get-cli-version.ts","../src/utils/pikku-cli-config.ts","../src/utils/pikku-files-and-methods.ts","../src/utils/schema-generator.ts","../src/utils/serialize-import-map.ts","../.pikku/pikku-bootstrap.gen.ts","../.pikku/pikku-services.gen.ts","../.pikku/pikku-types.gen.ts","../.pikku/pikku-websocket.gen.ts","../.pikku/channel/pikku-channel-types.gen.ts","../.pikku/channel/pikku-channels-map.gen.d.ts","../.pikku/channel/pikku-channels-meta.gen.ts","../.pikku/channel/pikku-channels.gen.ts","../.pikku/cli/pikku-cli-channel.gen.ts","../.pikku/cli/pikku-cli-client.gen.ts","../.pikku/cli/pikku-cli-types.gen.ts","../.pikku/cli/pikku-cli-wirings-meta.gen.ts","../.pikku/cli/pikku-cli-wirings.gen.ts","../.pikku/cli/pikku-cli.gen.ts","../.pikku/function/pikku-function-types.gen.ts","../.pikku/function/pikku-functions-meta.gen.ts","../.pikku/function/pikku-functions-meta.min.gen.ts","../.pikku/function/pikku-functions.gen.ts","../.pikku/http/pikku-http-types.gen.ts","../.pikku/http/pikku-http-wirings-map.gen.d.ts","../.pikku/http/pikku-http-wirings-meta.gen.ts","../.pikku/http/pikku-http-wirings.gen.ts","../.pikku/mcp/pikku-mcp-types.gen.ts","../.pikku/mcp/pikku-mcp-wirings-meta.gen.ts","../.pikku/mcp/pikku-mcp-wirings.gen.ts","../.pikku/queue/pikku-queue-types.gen.ts","../.pikku/queue/pikku-queue-workers-wirings-map.gen.d.ts","../.pikku/queue/pikku-queue-workers-wirings-meta.gen.ts","../.pikku/queue/pikku-queue-workers-wirings.gen.ts","../.pikku/rpc/pikku-rpc-wirings-map.gen.d.ts","../.pikku/rpc/pikku-rpc-wirings-map.internal.gen.d.ts","../.pikku/rpc/pikku-rpc-wirings-meta.internal.gen.ts","../.pikku/scheduler/pikku-scheduler-types.gen.ts","../.pikku/scheduler/pikku-schedulers-wirings-meta.gen.ts","../.pikku/scheduler/pikku-schedulers-wirings.gen.ts","../.pikku/schemas/register.gen.ts","../types/application-types.d.ts","../types/config.d.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.15",
+  "version": "0.10.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -11,9 +11,9 @@
   "module": "dist/bin/pikku.js",
   "scripts": {
     "tsc": "tsc",
-    "build:esm": "tsc -b",
-    "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
-    "build": "yarn build:esm && yarn schema",
+    "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/utils/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
+    "build": "yarn build:esm",
+    "build:esm": "./build.sh",
     "ncu": "npx npm-check-updates -x '/.*glob.*/'",
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
@@ -21,22 +21,24 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "dependencies": {
-    "@openapi-contrib/json-schema-to-openapi-schema": "^4.0.2",
-    "@pikku/core": "^0.9.9",
-    "@pikku/inspector": "^0.9.5",
+    "@openapi-contrib/json-schema-to-openapi-schema": "^4.2.0",
+    "@pikku/core": "^0.10.0",
+    "@pikku/inspector": "^0.10.0",
     "@types/cookie": "^1.0.0",
-    "@types/uuid": "^10.0.0",
-    "chalk": "^5.5.0",
+    "@types/json-schema": "^7.0.15",
+    "@types/uuid": "^11.0.0",
+    "chalk": "^5.6.2",
     "chokidar": "^4.0.3",
     "commander": "^14",
-    "path-to-regexp": "^8.2.0",
+    "openapi-types": "^12.1.3",
+    "path-to-regexp": "^8.3.0",
     "tinyglobby": "^0.2.12",
     "ts-json-schema-generator": "^2.4.0",
     "typescript": "^5.9",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@types/node": "^24.2.1"
+    "@types/node": "^24.9.1"
   },
   "engines": {
     "node": ">=18"

package/pikku.config.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://raw.githubusercontent.com/pikkujs/pikku/refs/heads/main/packages/cli/cli.schema.json",
+  "tsconfig": "./tsconfig.json",
+  "srcDirectories": ["src", "bin", "types"],
+  "outDir": ".pikku",
+  "packageMappings": {
+    "../inspector/src": "@pikku/inspector"
+  },
+  "supportsImportAttributes": true,
+  "schemasFromTypes": ["PikkuCLIConfig"],
+  "websocketFile": ".pikku/pikku-websocket.gen.ts",
+  "cli": {
+    "entrypoints": {
+      "pikku": [
+        ".pikku/cli/pikku-cli.gen.ts",
+        {
+          "type": "channel",
+          "wirePath": ".pikku/cli/pikku-cli-channel.gen.ts",
+          "path": ".pikku/cli/pikku-cli-client.gen.ts",
+          "name": "pikku-cli",
+          "route": "/cli/pikku"
+        }
+      ]
+    }
+  }
+}

package/src/cli.wiring.ts

@@ -0,0 +1,102 @@
+import { pikkuSchemas } from './functions/wirings/functions/schemas.js'
+import { pikkuFetch } from './functions/wirings/fetch/index.js'
+import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js'
+import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js'
+import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js'
+import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js'
+import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
+import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
+import { all } from './functions/commands/all.js'
+import { clientCLIRenderer } from './services.js'
+
+wireCLI({
+  program: 'pikku',
+  description:
+    'Pikku CLI - Code generation tool for type-safe backend development',
+  render: clientCLIRenderer,
+  options: {
+    config: {
+      description: 'Path to pikku.config.json file',
+      short: 'c',
+    },
+    logLevel: {
+      description: 'Set log level',
+      default: 'info' as const,
+      short: 'l',
+    },
+    userSessionType: {
+      description:
+        'Specify which UserSession type to use (when multiple exist)',
+    },
+    singletonServicesFactoryType: {
+      description: 'Specify which singleton services factory to use',
+    },
+    sessionServicesFactoryType: {
+      description: 'Specify which session services factory to use',
+    },
+    stateOutput: {
+      description: 'Save inspector state to JSON file for reuse',
+    },
+    stateInput: {
+      description: 'Load inspector state from JSON file (skips inspection)',
+    },
+  },
+  commands: {
+    all: pikkuCLICommand({
+      func: all,
+      description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
+      isDefault: true,
+      options: {
+        tags: {
+          description: 'Filter functions by tags (comma-separated)',
+          short: 't',
+        },
+        types: {
+          description: 'Filter functions by types (comma-separated)',
+        },
+        directories: {
+          description: 'Filter functions by directories (comma-separated)',
+          short: 'd',
+        },
+        httpMethods: {
+          description: 'Filter HTTP routes by methods (comma-separated)',
+        },
+        httpRoutes: {
+          description: 'Filter HTTP routes by route patterns (comma-separated)',
+        },
+        names: {
+          description: 'Filter functions by name patterns (supports wildcards)',
+          short: 'n',
+        },
+      },
+    }),
+    schemas: pikkuCLICommand({
+      func: pikkuSchemas,
+      description: 'Generate JSON schemas for function input/output types',
+    }),
+    fetch: pikkuCLICommand({
+      func: pikkuFetch,
+      description: 'Generate type-safe HTTP fetch client',
+    }),
+    websocket: pikkuCLICommand({
+      func: pikkuWebSocketTyped,
+      description: 'Generate type-safe WebSocket client',
+    }),
+    rpc: pikkuCLICommand({
+      func: pikkuRPCClient,
+      description: 'Generate RPC client wrappers',
+    }),
+    'queue-service': pikkuCLICommand({
+      func: pikkuQueueService,
+      description: 'Generate queue service wrapper',
+    }),
+    openapi: pikkuCLICommand({
+      func: pikkuOpenAPI,
+      description: 'Generate OpenAPI specification from HTTP routes',
+    }),
+    nextjs: pikkuCLICommand({
+      func: pikkuNext,
+      description: 'Generate Next.js backend and HTTP wrappers',
+    }),
+  },
+})