@pikku/cli 0.9.15 → 0.9.16-next.0

package/dist/src/functions/wirings/queue/pikku-command-queue-map.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueMap } from './serialize-queue-map.js';
+export const pikkuQueueMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { queueWorkers, functions } = await getInspectorState();
+        const { queueMapDeclarationFile, packageMappings } = config;
+        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        await writeFileInDir(logger, queueMapDeclarationFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Queue map',
+            commandEnd: 'Created Queue map',
+            skipCondition: async ({ getInspectorState }) => {
+                const { queueWorkers } = await getInspectorState();
+                return queueWorkers.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

package/dist/src/functions/wirings/queue/pikku-command-queue-service.d.ts

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

package/dist/src/functions/wirings/queue/pikku-command-queue-service.js

@@ -0,0 +1,24 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueWrapper } from './serialize-queue-wrapper.js';
+export const pikkuQueueService = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
+        if (!queueWiringsFile) {
+            throw new Error("queueWiringsFile is isn't set in the pikku config");
+        }
+        const queueMapDeclarationPath = getFileImportRelativePath(queueWiringsFile, queueMapDeclarationFile, packageMappings);
+        const content = [serializeQueueWrapper(queueMapDeclarationPath)];
+        await writeFileInDir(logger, queueWiringsFile, content.join('\n'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating queue service wrapper',
+            commandEnd: 'Generated queue service wrapper',
+            skipCondition: ({ config }) => config.queueWiringsFile === undefined,
+            skipMessage: "queueWiringsFile isn't set in the pikku config",
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,21 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueTypes } from './serialize-queue-types.js';
+export const pikkuQueueTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { queueTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(queueTypesFile, functionTypesFile, packageMappings);
+        const content = serializeQueueTypes(functionTypesImportPath);
+        await writeFileInDir(logger, queueTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating queue types',
+            commandEnd: 'Created queue types',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,26 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueMeta } from './serialize-queue-meta.js';
+export const pikkuQueue = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
+        const { queueWorkers } = visitState;
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Queues',
+            commandEnd: 'Found Queues',
+            skipCondition: async ({ getInspectorState }) => {
+                const visitState = await getInspectorState();
+                return visitState.queueWorkers.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

package/dist/src/functions/wirings/queue/pikku-queue-map.d.ts

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

package/dist/src/functions/wirings/queue/pikku-queue-map.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueMap } from './serialize-queue-map.js';
+export const pikkuQueueMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { queueWorkers, functions } = await getInspectorState();
+        const { queueMapDeclarationFile, packageMappings } = config;
+        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        await writeFileInDir(logger, queueMapDeclarationFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Queue map',
+            commandEnd: 'Created Queue map',
+            skipCondition: async ({ getInspectorState }) => {
+                const { queueWorkers } = await getInspectorState();
+                return queueWorkers.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

package/dist/src/functions/wirings/queue/pikku-queue.d.ts

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

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeQueueMeta } from './serialize-queue-meta.js';
+export const pikkuQueue = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { queueWorkersWiringFile, queueWorkersWiringMetaFile, packageMappings, } = config;
+        const { queueWorkers } = visitState;
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding queues',
+            commandEnd: 'Found queue',
+            skipCondition: async ({ getInspectorState }) => {
+                const { queueWorkers } = await getInspectorState();
+                return queueWorkers.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

package/dist/src/{wirings → functions/wirings}/queue/serialize-queue-map.js

@@ -1,5 +1,5 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
 export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);

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

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

package/dist/src/functions/wirings/queue/serialize-queue-types.js

@@ -0,0 +1,31 @@
+/**
+ * Generates type definitions for queue wirings
+ */
+export const serializeQueueTypes = (functionTypesImportPath) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * Queue-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
+import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+
+/**
+ * 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 QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+
+/**
+ * Registers a queue worker with the Pikku framework.
+ * Workers process background jobs from queues.
+ *
+ * @param queueWorker - Queue worker definition with job handler
+ */
+export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
+  wireQueueWorkerCore(queueWorker as any) // TODO
+}
+`;
+};

package/dist/src/functions/wirings/rpc/pikku-command-rpc-client.d.ts

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

package/dist/src/functions/wirings/rpc/pikku-command-rpc-client.js

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
+export const pikkuRPCClient = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config;
+        if (!rpcWiringsFile) {
+            return;
+            // TODO:  throw new Error("rpcWiringsFile isn't set in the pikku config")
+        }
+        const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
+        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
+        await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating RPC wrappers',
+            commandEnd: 'Generated RPC wrappers',
+            skipCondition: ({ config }) => config.rpcWiringsFile === undefined,
+            skipMessage: "rpcWiringsFile isn't set in the pikku config",
+        }),
+    ],
+});

package/dist/src/functions/wirings/rpc/pikku-command-rpc-map.d.ts

@@ -0,0 +1,2 @@
+export declare const pikkuRPCInternalMap: any;
+export declare const pikkuRPCExposedMap: any;

package/dist/src/functions/wirings/rpc/pikku-command-rpc-map.js

@@ -0,0 +1,36 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
+export const pikkuRPCInternalMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { functions, rpc } = await getInspectorState();
+        const { rpcInternalMapDeclarationFile, packageMappings } = config;
+        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
+        await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating RPC internal map',
+            commandEnd: 'Created RPC internal map',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});
+export const pikkuRPCExposedMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { functions, rpc } = await getInspectorState();
+        const { rpcMapDeclarationFile, packageMappings } = config;
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
+        await writeFileInDir(logger, rpcMapDeclarationFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating RPC external map',
+            commandEnd: 'Created RPC external map',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,22 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+export const pikkuRPC = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { rpc } = await getInspectorState();
+        const { rpcInternalWiringMetaFile } = config;
+        if (rpc.internalFiles.size > 0) {
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding RPCs tasks',
+            commandEnd: 'Found RPCs',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

package/dist/src/{wirings → functions/wirings}/rpc/serialize-typed-rpc-map.js

@@ -1,5 +1,5 @@
-import { serializeImportMap } from '../../serialize-import-map.js';
-import { generateCustomTypes } from '../../utils.js';
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
 export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);

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

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

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

@@ -0,0 +1,21 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSchedulerTypes } from './serialize-scheduler-types.js';
+export const pikkuSchedulerTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { schedulersTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(schedulersTypesFile, functionTypesFile, packageMappings);
+        const content = serializeSchedulerTypes(functionTypesImportPath);
+        await writeFileInDir(logger, schedulersTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating cheduler types',
+            commandEnd: 'Created scheduler types',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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

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

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

@@ -0,0 +1,26 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
+export const pikkuScheduler = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings } = config;
+        const { scheduledTasks } = visitState;
+        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Scheduled tasks',
+            commandEnd: 'Found Scheduled tasks',
+            skipCondition: async ({ getInspectorState }) => {
+                const visitState = await getInspectorState();
+                return visitState.scheduledTasks.files.size === 0;
+            },
+            skipMessage: 'none found',
+        }),
+    ],
+});

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

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

package/dist/src/functions/wirings/scheduler/serialize-scheduler-types.js

@@ -0,0 +1,29 @@
+/**
+ * Generates type definitions for scheduler wirings
+ */
+export const serializeSchedulerTypes = (functionTypesImportPath) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * Scheduler-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
+import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for scheduled tasks that run at specified intervals.
+ * These are sessionless functions that execute based on cron expressions.
+ */
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionConfig<void, void>, PikkuMiddleware>
+
+/**
+ * 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 wireScheduler = (task: SchedulerWiring) => {
+  wireSchedulerCore(task as any) // TODO
+}
+`;
+};

package/dist/src/middleware/log-command-info-and-time.d.ts

@@ -0,0 +1,19 @@
+import type { SingletonServices, Services } from '../../types/application-types.js';
+import type { PikkuInteraction } from '@pikku/core';
+type PikkuMiddleware = (services: Services, interaction: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+export interface LogCommandInfoOptions {
+    commandStart: string;
+    commandEnd: string;
+    skipCondition?: boolean | ((services: SingletonServices) => boolean | Promise<boolean>);
+    skipMessage?: string;
+}
+/**
+ * Middleware to log command execution timing and status
+ * Replaces the logCommandInfoAndTime wrapper function
+ *
+ * The skipCondition can be:
+ * - A boolean valuewe
+ * - A function that receives services and returns a boolean (can access getInspectorState)
+ */
+export declare const logCommandInfoAndTime: ({ commandStart, commandEnd, skipCondition, skipMessage, }: LogCommandInfoOptions) => PikkuMiddleware;
+export {};

package/dist/src/middleware/log-command-info-and-time.js

@@ -0,0 +1,27 @@
+/**
+ * Middleware to log command execution timing and status
+ * Replaces the logCommandInfoAndTime wrapper function
+ *
+ * The skipCondition can be:
+ * - A boolean valuewe
+ * - A function that receives services and returns a boolean (can access getInspectorState)
+ */
+export const logCommandInfoAndTime = ({ commandStart, commandEnd, skipCondition = false, skipMessage = 'none found', }) => {
+    return async ({ logger, ...services }, _interaction, next) => {
+        // Evaluate skip condition (can be boolean or function)
+        const shouldSkip = typeof skipCondition === 'function'
+            ? await skipCondition({ logger, ...services })
+            : skipCondition;
+        if (shouldSkip === true) {
+            logger.info(`• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`);
+            return;
+        }
+        // Log start
+        const start = Date.now();
+        logger.info(`• ${commandStart}...`);
+        // Execute the function
+        await next();
+        // Log completion
+        logger.info(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
+    };
+};

package/dist/src/services/cli-logger-forwarder.service.d.ts

@@ -0,0 +1,26 @@
+import { Logger, LogLevel, PikkuChannel } from '@pikku/core';
+/**
+ * Log message structure sent through the channel
+ */
+export interface ForwardedLogMessage {
+    message: string;
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    type?: string;
+}
+/**
+ * A logger implementation that forwards log messages to a CLI channel
+ * instead of logging to console directly.
+ */
+export declare class CLILoggerForwarder implements Logger {
+    private logger;
+    private channel;
+    private level;
+    constructor(logger: Logger, channel: PikkuChannel<unknown, ForwardedLogMessage>);
+    setLevel(level: LogLevel): void;
+    private log;
+    info(messageOrObj: string | Record<string, any>, ..._meta: any[]): void;
+    error(messageOrObj: string | Record<string, any> | Error, ..._meta: any[]): void;
+    warn(messageOrObj: string | Record<string, any>, ..._meta: any[]): void;
+    debug(message: string, ..._meta: any[]): void;
+    trace(message: string, ..._meta: any[]): void;
+}

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

@@ -0,0 +1,55 @@
+import { LogLevel } from '@pikku/core';
+/**
+ * A logger implementation that forwards log messages to a CLI channel
+ * instead of logging to console directly.
+ */
+export class CLILoggerForwarder {
+    logger;
+    channel;
+    level = LogLevel.info;
+    constructor(logger, channel) {
+        this.logger = logger;
+        this.channel = channel;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    log(level, logLevel, messageOrObj, type) {
+        if (this.level > logLevel)
+            return;
+        let message;
+        if (messageOrObj instanceof Error) {
+            this.logger.error(messageOrObj);
+            message = messageOrObj.message;
+        }
+        else if (typeof messageOrObj === 'object') {
+            if ('message' in messageOrObj &&
+                typeof messageOrObj.message === 'string') {
+                message = messageOrObj.message;
+                type = type || messageOrObj.type;
+            }
+            else {
+                message = JSON.stringify(messageOrObj);
+            }
+        }
+        else {
+            message = messageOrObj;
+        }
+        this.channel.send({ message, level, type });
+    }
+    info(messageOrObj, ..._meta) {
+        this.log('info', LogLevel.info, messageOrObj);
+    }
+    error(messageOrObj, ..._meta) {
+        this.log('error', LogLevel.error, messageOrObj);
+    }
+    warn(messageOrObj, ..._meta) {
+        this.log('warn', LogLevel.warn, messageOrObj);
+    }
+    debug(message, ..._meta) {
+        this.log('debug', LogLevel.debug, message);
+    }
+    trace(message, ..._meta) {
+        this.log('trace', LogLevel.trace, message);
+    }
+}

package/dist/src/services/cli-logger.service.d.ts

@@ -0,0 +1,19 @@
+import { Logger, LogLevel } from '@pikku/core';
+export declare class CLILogger implements Logger {
+    private silent;
+    private level;
+    constructor({ logLogo, silent, }: {
+        logLogo: boolean;
+        silent?: boolean;
+    });
+    setLevel(level: LogLevel): void;
+    info(message: string | {
+        message: string;
+        type?: string;
+    }): void;
+    error(message: string): void;
+    warn(message: string): void;
+    debug(message: string): void;
+    private logPikkuLogo;
+    private primary;
+}

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));
+        }
+    }
+}