@pikku/cli 0.7.7 → 0.8.0

package/dist/src/serialize-pikku-types.js

@@ -11,43 +11,158 @@ import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/functio
 import { CoreHTTPFunctionRoute, AssertRouteParams, addHTTPRoute as addCoreHTTPRoute } from '@pikku/core/http'
 import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
 import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
+import { CoreQueueWorker, addQueueWorker as addCoreQueueWorker } from '@pikku/core/queue'
+import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, addMCPResource as addCoreMCPResource, addMCPTool as addCoreMCPTool, addMCPPrompt as addCoreMCPPrompt, MCPResourceResponse, MCPToolResponse, MCPPromptResponse, PikkuMCP } from '@pikku/core'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
 ${rpcMapTypeImport}
 
+/**
+ * Type-safe API permission definition that integrates with your application's session type.
+ * Use this to define authorization logic for your API endpoints.
+ * 
+ * @template In - The input type that the permission check will receive
+ * @template RequiredServices - The services required for this permission check
+ */
 export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+
+/**
+ * Type-safe middleware definition that can access your application's services and session.
+ * Use this to define reusable middleware that can be applied to multiple routes.
+ * 
+ * @template RequiredServices - The services required for this middleware
+ */
 export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
 
+/**
+ * A sessionless API function that doesn't require user authentication.
+ * Use this for public endpoints, health checks, or operations that don't need user context.
+ * 
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
 type APIFunctionSessionless<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
   RequiredServices extends Services = Services &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
   )
 > = CoreAPIFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
+/**
+ * A session-aware API function that requires user authentication.
+ * Use this for protected endpoints that need access to user session data.
+ * 
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
 type APIFunction<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
   RequiredServices extends Services = Services &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
   )
 > = CoreAPIFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
+/**
+ * Type definition for HTTP API routes with type-safe path parameters.
+ * Supports both authenticated and unauthenticated functions.
+ * 
+ * @template In - Input type for the route
+ * @template Out - Output type for the route
+ * @template Route - String literal type for the route path (e.g., "/users/:id")
+ */
 type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+
+/**
+ * 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 APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<void, unknown> | APIFunction<void, unknown, ChannelData>, APIFunction<void, void> | APIFunction<void, void, ChannelData>, APIFunction<any, any> | APIFunction<any, any, ChannelData>, APIPermission>
-type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
 
+/**
+ * Type definition for scheduled tasks that run at specified intervals.
+ * These are sessionless functions that execute based on cron expressions.
+ */
+type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>>
+
+/**
+ * Type definition for queue workers that process background jobs.
+ * 
+ * @template In - Input type for the queue job
+ * @template Out - Output type for the queue job
+ */
+type QueueWorker<In, Out> = CoreQueueWorker<APIFunctionSessionless<In, Out>>
+
+/**
+ * Type definition for MCP resources that provide data to AI models.
+ * 
+ * @template In - Input type for the resource request
+ */
+type MCPResource<In> = CoreMCPResource<APIFunctionSessionless<In, MCPResourceResponse, null, true>>
+
+/**
+ * Type definition for MCP tools that AI models can invoke.
+ * 
+ * @template In - Input type for the tool invocation
+ */
+type MCPTool<In> = CoreMCPTool<APIFunctionSessionless<In, MCPToolResponse, null, true>>
+
+/**
+ * Type definition for MCP prompts that provide templates to AI models.
+ * 
+ * @template In - Input type for the prompt parameters
+ */
+type MCPPrompt<In> = CoreMCPPrompt<APIFunctionSessionless<In, MCPPromptResponse, null, true>>
+
+/**
+ * Creates a Pikku function that can be either session-aware or sessionless.
+ * This is the main function wrapper for creating API endpoints.
+ * 
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
+ *   func: async ({db, logger}, input) => {
+ *     logger.info('Creating user', input.name)
+ *     const user = await db.users.create(input)
+ *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
+ *   },
+ *   auth: true
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuFunc = <In, Out = unknown>(
   func:
     | APIFunction<In, Out>
@@ -65,6 +180,26 @@ export const pikkuFunc = <In, Out = unknown>(
   return typeof func === 'function' ? func : func.func
 }
 
+/**
+ * Creates a sessionless Pikku function that doesn't require user authentication.
+ * Use this for public endpoints, webhooks, or background tasks.
+ * 
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
+ *   func: async ({logger}) => {
+ *     logger.info('Health check requested')
+ *     return {status: 'healthy', timestamp: new Date().toISOString()}
+ *   },
+ *   name: 'healthCheck'
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuSessionlessFunc = <In, Out = unknown>(
   func:
     | APIFunctionSessionless<In, Out>
@@ -76,6 +211,26 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
   return typeof func === 'function' ? func : func.func
 }
 
+/**
+ * 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
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const onChatConnect = pikkuChannelConnectionFunc<string>({
+ *   func: async ({logger, channel, eventHub}) => {
+ *     logger.info('User connected to chat')
+ *     await eventHub.publish('chat:join', channel.channelId, {channelId: channel.channelId})
+ *     return 'Welcome to the chat!'
+ *   }
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
   func:
     | APIFunctionSessionless<void, Out, ChannelData>
@@ -87,6 +242,24 @@ export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>
   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
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const onChatDisconnect = pikkuChannelDisconnectionFunc({
+ *   func: async ({logger, channel, eventHub}) => {
+ *     logger.info('User disconnected from chat')
+ *     await eventHub.publish('chat:join', channel.channelId, {channelId: channel.channelId})
+ *   }
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
   func:
     | APIFunctionSessionless<void, void, ChannelData>
@@ -98,6 +271,25 @@ export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
   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
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const handleChatMessage = pikkuChannelFunc<{message: string}, void>({
+ *   func: async ({logger, channel}, input) => {
+ *     logger.info('Chat message received:', input.message)
+ *   }
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
   func:
     | APIFunctionSessionless<In, Out, ChannelData>
@@ -109,6 +301,22 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
   return typeof func === 'function' ? func : func.func
 }
 
+/**
+ * Creates a function that takes no input and returns no output.
+ * Useful for health checks, triggers, or cleanup operations.
+ * 
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
+ *     logger.info('Starting cleanup of temporary files')
+ *     await fileSystem.deleteDirectory('/tmp/uploads')
+ *     logger.info('Cleanup completed')
+ * })
+ * \\\`\\\`\\\`
+ */
 export const pikkuVoidFunc = (
   func:
     | APIFunctionSessionless<void, void>
@@ -120,20 +328,189 @@ export const pikkuVoidFunc = (
   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 addChannel = <ChannelData, Channel extends string>(
   channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
 ) => {
   addCoreChannel(channel as any) // TODO
 }
 
+/**
+ * Registers an HTTP route with the Pikku framework.
+ * 
+ * @template In - Input type for the route
+ * @template Out - Output type for the route
+ * @template Route - String literal type for the route path (e.g., "/users/:id")
+ * @param route - Route definition with handler, method, and optional middleware
+ */
 export const addHTTPRoute = <In, Out, Route extends string>(
   route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
 ) => {
   addCoreHTTPRoute(route)
 }
 
+/**
+ * Registers a scheduled task with the Pikku framework.
+ * Tasks run based on cron expressions and are sessionless.
+ * 
+ * @param task - Scheduled task definition with cron expression and handler
+ */
 export const addScheduledTask = (task: ScheduledTask) => {
   addCoreScheduledTask(task as any) // TODO
 }
+
+/**
+ * Registers a queue worker with the Pikku framework.
+ * Workers process background jobs from queues.
+ * 
+ * @param queueWorker - Queue worker definition with job handler
+ */
+export const addQueueWorker = (queueWorker: QueueWorker<any, any>) => {
+  addCoreQueueWorker(queueWorker as any) // TODO
+}
+
+/**
+ * Registers an MCP resource with the Pikku framework.
+ * Resources provide data that AI models can access.
+ * 
+ * @template In - Input type for the resource request
+ * @param mcpResource - MCP resource definition with data provider function
+ */
+export const addMCPResource = <In>(
+  mcpResource: MCPResource<In>
+) => {
+  addCoreMCPResource(mcpResource as any)
+}
+
+/**
+ * Registers an MCP tool with the Pikku framework.
+ * Tools are functions that AI models can invoke.
+ * 
+ * @template In - Input type for the tool invocation
+ * @param mcpTool - MCP tool definition with action function
+ */
+export const addMCPTool = <In>(
+  mcpTool: MCPTool<In>
+) => {
+  addCoreMCPTool(mcpTool as any)
+}
+
+/**
+ * Registers an MCP prompt with the Pikku framework.
+ * Prompts provide templates that AI models can use.
+ * 
+ * @template In - Input type for the prompt parameters
+ * @param mcpPrompt - MCP prompt definition with template function
+ */
+export const addMCPPrompt = <In>(
+  mcpPrompt: MCPPrompt<In>
+) => {
+  addCoreMCPPrompt(mcpPrompt as any)
+}
+
+/**
+ * Creates a function for handling MCP prompt requests.
+ * These functions generate prompt templates for AI models.
+ * 
+ * @template In - Input type for the prompt parameters
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \`\`\`typescript
+ * const codeReviewPrompt = pikkuMCPPromptFunc<{language: string, code: string}>({
+ *   func: async ({}, input) => ({
+ *     messages: [{
+ *       role: 'user',
+ *       content: {
+ *         type: 'text',
+ *         text: \`Please review this \${input.language} code: \${input.code}\`
+ *       }
+ *     }]
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuMCPPromptFunc = <In>(
+  func:
+    | APIFunctionSessionless<In, MCPPromptResponse>
+    | {
+        func: APIFunctionSessionless<In, MCPPromptResponse>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function for handling MCP tool invocations.
+ * These functions perform actions that AI models can request.
+ * 
+ * @template In - Input type for the tool invocation
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \`\`\`typescript
+ * const searchFiles = pikkuMCPToolFunc<{query: string, directory: string}>({
+ *   func: async ({fileSystem}, input) => {
+ *     const results = await fileSystem.search(input.query, input.directory)
+ *     return [{
+ *         type: 'text',
+ *         text: \`Found \${results.length} files matching \"\${input.query}\"\`
+ *       }]
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuMCPToolFunc = <In>(
+  func:
+    | APIFunctionSessionless<In, MCPToolResponse, null, true>
+    | {
+      func: APIFunctionSessionless<In, MCPToolResponse, null, true>
+      name?: string
+    }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+/**
+ * Creates a function for handling MCP resource requests.
+ * These functions provide data that AI models can access.
+ * 
+ * @template In - Input type for the resource request
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ * 
+ * @example
+ * \`\`\`typescript
+ * const getProjectFiles = pikkuMCPResourceFunc<{path: string}>({
+ *   func: async ({ fileSystem }, input) => {
+ *     const fileContent = await fileSystem.readFile(input.path)
+ *     return [{
+ *         uri: \`file://\${input.path}\`,
+ *         mimeType: 'text/plain',
+ *         text: fileContent
+ *       }]
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuMCPResourceFunc = <In>(
+  func:
+    | APIFunctionSessionless<In, MCPResourceResponse, null, true>
+    | {
+      func: APIFunctionSessionless<In, MCPResourceResponse, null, true>
+      name?: string
+    }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
 `;
 };

package/dist/src/types.d.ts

@@ -0,0 +1,5 @@
+import { InspectorState } from '@pikku/inspector';
+import { PikkuCLIConfig } from './pikku-cli-config.js';
+import { CLILogger, PikkuCLIOptions } from './utils.js';
+export type PikkuCommand = (logger: CLILogger, cliConfig: PikkuCLIConfig, visitState: InspectorState, options?: PikkuCLIOptions) => Promise<boolean>;
+export type PikkuCommandWithoutState = (logger: CLILogger, cliConfig: PikkuCLIConfig, options?: PikkuCLIOptions) => Promise<boolean>;

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/{utils/utils.d.ts → utils.d.ts}

@@ -1,7 +1,15 @@
 import { InspectorState, TypesMap } from '@pikku/inspector';
-export declare const logPrimary: (message: string) => void;
-export declare const logSuccess: (message: string) => void;
-export declare const logInfo: (message: string) => void;
+export declare class CLILogger {
+    constructor({ logLogo }: {
+        logLogo: boolean;
+    });
+    primary(message: string): void;
+    success(message: string): void;
+    info(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    private logPikkuLogo;
+}
 export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
 interface Meta {
     file: string;
@@ -26,7 +34,7 @@ export interface PikkuCLIOptions {
     sessionServicesFactoryType?: string;
     tags?: string[];
 }
-export declare const getPikkuFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
+export declare const getPikkuFilesAndMethods: (logger: CLILogger, { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
     config: boolean;
     sessionServiceType: boolean;
     singletonServicesType: boolean;
@@ -34,9 +42,11 @@ export declare const getPikkuFilesAndMethods: ({ singletonServicesTypeImportMap,
     singletonServicesFactory: boolean;
     sessionServicesFactory: boolean;
 }>) => Promise<FilesAndMethods>;
-export declare const writeFileInDir: (path: string, content: string, ignoreModifyComment?: boolean) => Promise<void>;
-export declare const logCommandInfoAndTime: (commandStart: string, commandEnd: string, [skipCondition, skipMessage]: [boolean] | [boolean, string], callback: (...args: any[]) => Promise<unknown>) => Promise<boolean>;
-export declare const logPikkuLogo: () => void;
+export declare const writeFileInDir: (logger: CLILogger, path: string, content: string, { ignoreModifyComment, logWrite, }?: {
+    ignoreModifyComment?: boolean;
+    logWrite?: boolean;
+}) => Promise<void>;
+export declare const logCommandInfoAndTime: (logger: CLILogger, commandStart: string, commandEnd: string, [skipCondition, skipMessage]: [boolean] | [boolean, string], callback: (...args: any[]) => Promise<unknown>) => Promise<boolean>;
 export declare const DO_NOT_MODIFY_COMMENT = "/**\n * This file was generated by the @pikku/cli\n */\n";
 export declare const serializeFileImports: (importType: string, outputPath: string, files: Set<string>, packageMappings?: Record<string, string>) => string;
 export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/{utils/utils.js → utils.js}

@@ -4,15 +4,41 @@ import chalk from 'chalk';
 import { fileURLToPath } from 'url';
 import { readFileSync } from 'fs';
 const __filename = fileURLToPath(import.meta.url);
-export const logPrimary = (message) => {
-    console.log(chalk.green(message));
-};
-export const logSuccess = (message) => {
-    console.log(chalk.green(message));
-};
-export const logInfo = (message) => {
-    console.log(chalk.blue(message));
-};
+const logo = `
+ ______ _ _     _           
+(_____ (_) |   | |          
+ _____) )| |  _| |  _ _   _ 
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (| |_| |
+|_|    |_|_| \_)_| \_)____/ 
+`;
+export class CLILogger {
+    constructor({ logLogo }) {
+        if (logLogo) {
+            this.logPikkuLogo();
+        }
+    }
+    primary(message) {
+        console.log(chalk.green(message));
+    }
+    success(message) {
+        console.log(chalk.green(message));
+    }
+    info(message) {
+        console.log(chalk.blue(message));
+    }
+    error(message) {
+        console.error(chalk.red(message));
+    }
+    warn(message) {
+        console.error(chalk.yellow(message));
+    }
+    logPikkuLogo() {
+        this.primary(logo);
+        const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8'));
+        this.primary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`);
+    }
+}
 export const getFileImportRelativePath = (from, to, packageMappings) => {
     let filePath = relative(dirname(from), to);
     if (!/^\.+\//.test(filePath)) {
@@ -60,7 +86,7 @@ const getMetaTypes = (type, errors, map, desiredType) => {
     }
     return undefined;
 };
-export const getPikkuFilesAndMethods = async ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, packageMappings, outputFile, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }, requires = {
+export const getPikkuFilesAndMethods = async (logger, { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, packageMappings, outputFile, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }, requires = {
     config: false,
     singletonServicesType: false,
     sessionServiceType: false,
@@ -86,12 +112,15 @@ export const getPikkuFilesAndMethods = async ({ singletonServicesTypeImportMap,
                 result.push(`\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`);
             }
         });
-        console.error(result.join('\n'));
+        logger.error(result.join('\n'));
         process.exit(1);
     }
     return result;
 };
-export const writeFileInDir = async (path, content, ignoreModifyComment = false) => {
+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}`);
     }
@@ -100,32 +129,21 @@ export const writeFileInDir = async (path, content, ignoreModifyComment = false)
     }
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, content, 'utf-8');
-    logSuccess(`✓ File written to ${path}`);
+    if (logWrite) {
+        logger.success(`✓ File written to ${path}`);
+    }
 };
-export const logCommandInfoAndTime = async (commandStart, commandEnd, [skipCondition, skipMessage = 'none found'], callback) => {
+export const logCommandInfoAndTime = async (logger, commandStart, commandEnd, [skipCondition, skipMessage = 'none found'], callback) => {
     if (skipCondition === true) {
-        logInfo(`• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`);
+        logger.info(`• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`);
         return false;
     }
     const start = Date.now();
     chalk.blue(`• ${commandStart}...`);
     await callback();
-    logSuccess(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
+    logger.success(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
     return true;
 };
-const logo = `
- ______ _ _     _           
-(_____ (_) |   | |          
- _____) )| |  _| |  _ _   _ 
-|  ____/ | |_/ ) |_/ ) | | |
-| |    | |  _ (|  _ (| |_| |
-|_|    |_|_| \_)_| \_)____/ 
-`;
-export const logPikkuLogo = () => {
-    logPrimary(logo);
-    const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8'));
-    logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`);
-};
 // TODO: add version back in once the ESM dust settles
 export const DO_NOT_MODIFY_COMMENT = `/**
  * This file was generated by the @pikku/cli

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc-map.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-typed-rpc-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils/serialize-import-map.ts","../src/utils/utils.ts"],"version":"5.7.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.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/events/channels/pikku-channels.ts","../src/events/channels/pikku-command-channels-map.ts","../src/events/channels/pikku-command-channels.ts","../src/events/channels/pikku-command-websocket-typed.ts","../src/events/channels/serialize-typed-channel-map.ts","../src/events/channels/serialize-websocket-wrapper.ts","../src/events/fetch/index.ts","../src/events/functions/pikku-command-function-types.ts","../src/events/functions/pikku-command-functions.ts","../src/events/functions/pikku-function-types.ts","../src/events/functions/pikku-functions.ts","../src/events/http/openapi-spec-generator.ts","../src/events/http/pikku-command-http-map.ts","../src/events/http/pikku-command-http-routes.ts","../src/events/http/pikku-command-nextjs.ts","../src/events/http/pikku-command-openapi.ts","../src/events/http/pikku-http-routes.ts","../src/events/http/serialize-fetch-wrapper.ts","../src/events/http/serialize-typed-http-map.ts","../src/events/mcp/pikku-command-mcp-json.ts","../src/events/mcp/pikku-command-mcp.ts","../src/events/mcp/serialize-mcp-json.ts","../src/events/queue/pikku-command-queue-map.ts","../src/events/queue/pikku-command-queue-service.ts","../src/events/queue/pikku-command-queue.ts","../src/events/queue/pikku-queue-map.ts","../src/events/queue/pikku-queue.ts","../src/events/queue/serialize-queue-map.ts","../src/events/queue/serialize-queue-meta.ts","../src/events/queue/serialize-queue-wrapper.ts","../src/events/rpc/pikku-command-rpc-map.ts","../src/events/rpc/pikku-command-rpc.ts","../src/events/rpc/pikku-rpc.ts","../src/events/rpc/serialize-typed-rpc-map.ts","../src/events/scheduler/pikku-command-scheduler.ts","../src/events/scheduler/serialize-scheduler-meta.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.7",
+  "version": "0.8.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.7.8",
-    "@pikku/inspector": "^0.7.7",
+    "@pikku/core": "^0.8.0",
+    "@pikku/inspector": "^0.8.0",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",