@pikku/cli 0.9.15 → 0.10.0

package/dist/src/functions/wirings/permissions/serialize-permissions-imports.js

@@ -0,0 +1,43 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializePermissionsImports = (outputPath, permissionsState, httpState, packageMappings = {}, fullState) => {
+    const serializedImports = [];
+    const serializedFactoryCalls = [];
+    // Collect factory imports and calls for HTTP permission groups
+    const httpFactories = new Map();
+    for (const [, groupMeta] of httpState.routePermissions.entries()) {
+        if (groupMeta.exportName && groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            httpFactories.set(groupMeta.exportName, {
+                exportName: groupMeta.exportName,
+                filePath,
+            });
+        }
+    }
+    // Collect factory imports and calls for tag permission groups
+    const tagFactories = new Map();
+    for (const [, groupMeta] of permissionsState.tagPermissions.entries()) {
+        if (groupMeta.exportName && groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            tagFactories.set(groupMeta.exportName, {
+                exportName: groupMeta.exportName,
+                filePath,
+            });
+        }
+    }
+    // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
+    const allFactories = new Map([...httpFactories, ...tagFactories]);
+    // Add factory imports and calls
+    if (allFactories.size > 0) {
+        serializedImports.push('/* Call permission group factories to register at module evaluation */');
+        // Import factories
+        for (const [exportName, { filePath }] of allFactories) {
+            serializedImports.push(`import { ${exportName} } from '${filePath}'`);
+        }
+        // Call factories
+        for (const [exportName] of allFactories) {
+            serializedFactoryCalls.push(`${exportName}()`);
+        }
+    }
+    // Return combined output
+    return [...serializedImports, ...serializedFactoryCalls].join('\n');
+};

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

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

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

@@ -0,0 +1,18 @@
+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',
+        }),
+    ],
+});

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,27 @@
+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 is not set, clean up any existing file and return
+        if (!queueWiringsFile) {
+            logger.info({
+                message: "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        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',
+        }),
+    ],
+});

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,19 @@
+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',
+        }),
+    ],
+});

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,21 @@
+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',
+        }),
+    ],
+});

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,18 @@
+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',
+        }),
+    ],
+});

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,21 @@
+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 queue',
+        }),
+    ],
+});

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/{wirings → functions/wirings}/queue/serialize-queue-meta.d.ts

@@ -1,2 +1,2 @@
-import { queueWorkersMeta } from '@pikku/core';
+import { queueWorkersMeta } from '@pikku/core/queue';
 export declare const serializeQueueMeta: (queueWorkersMeta: queueWorkersMeta) => string;

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,30 @@
+/**
+ * Generates type definitions for queue wirings
+ */
+export const serializeQueueTypes = (functionTypesImportPath) => {
+    return `/**
+ * 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,27 @@
+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 is not set, clean up any existing file and return
+        if (!rpcWiringsFile) {
+            logger.info({
+                message: "Skipping generating RPC wrappers since rpcWiringsFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        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',
+        }),
+    ],
+});

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,32 @@
+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',
+        }),
+    ],
+});
+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',
+        }),
+    ],
+});

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,20 @@
+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',
+        }),
+    ],
+});

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,19 @@
+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',
+        }),
+    ],
+});

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,21 @@
+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',
+        }),
+    ],
+});

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,28 @@
+/**
+ * Generates type definitions for scheduler wirings
+ */
+export const serializeSchedulerTypes = (functionTypesImportPath) => {
+    return `/**
+ * 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,13 @@
+import type { 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;
+}
+/**
+ * Middleware to log command execution timing and status
+ * Replaces the logCommandInfoAndTime wrapper function
+ */
+export declare const logCommandInfoAndTime: ({ commandStart, commandEnd, }: LogCommandInfoOptions) => PikkuMiddleware;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * Middleware to log command execution timing and status
+ * Replaces the logCommandInfoAndTime wrapper function
+ */
+export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
+    return async ({ logger }, _interaction, next) => {
+        // 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,30 @@
+import { Logger, LogLevel } from '@pikku/core';
+import { PikkuChannel } from '@pikku/core/channel';
+import { ErrorCode } from '@pikku/inspector';
+/**
+ * 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, any>);
+    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;
+    critical(code: ErrorCode, message: string): void;
+    hasCriticalErrors(): boolean;
+}

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

@@ -0,0 +1,64 @@
+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);
+    }
+    critical(code, message) {
+        const url = `https://pikku.dev/docs/cli-errors/${code.toLowerCase()}`;
+        const formattedMessage = `[${code}] ${message}\n  → ${url}`;
+        this.error(formattedMessage);
+    }
+    hasCriticalErrors() {
+        // The underlying logger (CLILogger) tracks critical errors
+        return this.logger.hasCriticalErrors?.() ?? false;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Logger, LogLevel } from '@pikku/core';
+import { ErrorCode } from '@pikku/inspector';
+export declare class CLILogger implements Logger {
+    private silent;
+    private level;
+    private criticalErrors;
+    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;
+    critical(code: ErrorCode, message: string): void;
+    hasCriticalErrors(): boolean;
+    private logPikkuLogo;
+    private primary;
+}