@pikku/cli 0.9.16-next.0 → 0.10.0

package/dist/src/functions/wirings/middleware/serialize-middleware-groups-meta.js

@@ -5,13 +5,7 @@
  * This includes services, middleware count, factory status, etc.
  */
 export const serializeMiddlewareGroupsMeta = (state) => {
-    const lines = [
-        `/**`,
-        ` * This file was generated by the @pikku/cli`,
-        ` */`,
-        `import { pikkuState } from '@pikku/core'`,
-        ``,
-    ];
+    const lines = [`import { pikkuState } from '@pikku/core'`, ``];
     // Serialize HTTP middleware groups metadata
     const httpGroups = {};
     for (const [pattern, meta] of state.http.routeMiddleware.entries()) {

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

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

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

@@ -0,0 +1,28 @@
+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 { serializePermissionsImports } from './serialize-permissions-imports.js';
+export const pikkuPermissions = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const state = await getInspectorState();
+        const { permissions } = state;
+        const { permissionsFile, packageMappings } = config;
+        let filesGenerated = false;
+        // Check if there are any permission group factories
+        const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
+        const hasFactories = hasHTTPFactories || hasTagFactories;
+        // Generate permissions imports file if there are factories
+        if (hasFactories) {
+            await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
+            filesGenerated = true;
+        }
+        return filesGenerated;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing Pikku permissions',
+            commandEnd: 'Serialized Pikku permissions',
+        }),
+    ],
+});

package/dist/src/functions/wirings/permissions/serialize-permissions-imports.d.ts

@@ -0,0 +1,2 @@
+import type { InspectorPermissionState, InspectorHTTPState, InspectorState } from '@pikku/inspector';
+export declare const serializePermissionsImports: (outputPath: string, permissionsState: InspectorPermissionState, httpState: InspectorHTTPState, packageMappings?: Record<string, string>, fullState?: InspectorState) => string;

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.js

@@ -13,11 +13,6 @@ export const pikkuQueueMap = pikkuSessionlessFunc({
         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.js

@@ -6,8 +6,13 @@ 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) {
-            throw new Error("queueWiringsFile is isn't set in the pikku config");
+            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)];
@@ -17,8 +22,6 @@ export const pikkuQueueService = pikkuSessionlessFunc({
         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.js

@@ -14,8 +14,6 @@ export const pikkuQueueTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating queue types',
             commandEnd: 'Created queue types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -16,11 +16,6 @@ export const pikkuQueue = pikkuSessionlessFunc({
         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.js

@@ -13,11 +13,6 @@ export const pikkuQueueMap = pikkuSessionlessFunc({
         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.js

@@ -10,16 +10,12 @@ export const pikkuQueue = pikkuSessionlessFunc({
         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',
-            skipCondition: async ({ getInspectorState }) => {
-                const { queueWorkers } = await getInspectorState();
-                return queueWorkers.files.size === 0;
-            },
-            skipMessage: 'none found',
         }),
     ],
 });

package/dist/src/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.js

@@ -3,7 +3,6 @@
  */
 export const serializeQueueTypes = (functionTypesImportPath) => {
     return `/**
- * This file was generated by the @pikku/cli
  * Queue-specific type definitions for tree-shaking optimization
  */
 

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

@@ -6,9 +6,13 @@ 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;
-            // TODO:  throw new Error("rpcWiringsFile isn't set in the pikku config")
         }
         const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
         const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
@@ -18,8 +22,6 @@ export const pikkuRPCClient = pikkuSessionlessFunc({
         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.js

@@ -13,8 +13,6 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating RPC internal map',
             commandEnd: 'Created RPC internal map',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });
@@ -29,8 +27,6 @@ export const pikkuRPCExposedMap = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating RPC external map',
             commandEnd: 'Created RPC external map',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -15,8 +15,6 @@ export const pikkuRPC = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Finding RPCs tasks',
             commandEnd: 'Found RPCs',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -14,8 +14,6 @@ export const pikkuSchedulerTypes = pikkuSessionlessFunc({
         logCommandInfoAndTime({
             commandStart: 'Creating cheduler types',
             commandEnd: 'Created scheduler types',
-            skipCondition: false,
-            skipMessage: '',
         }),
     ],
 });

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

@@ -16,11 +16,6 @@ export const pikkuScheduler = pikkuSessionlessFunc({
         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.js

@@ -3,7 +3,6 @@
  */
 export const serializeSchedulerTypes = (functionTypesImportPath) => {
     return `/**
- * This file was generated by the @pikku/cli
  * Scheduler-specific type definitions for tree-shaking optimization
  */
 

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

@@ -1,19 +1,13 @@
-import type { SingletonServices, Services } from '../../types/application-types.js';
+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;
-    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 declare const logCommandInfoAndTime: ({ commandStart, commandEnd, }: LogCommandInfoOptions) => PikkuMiddleware;
 export {};

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

@@ -1,21 +1,9 @@
 /**
  * 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;
-        }
+export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
+    return async ({ logger }, _interaction, next) => {
         // Log start
         const start = Date.now();
         logger.info(`• ${commandStart}...`);

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

@@ -1,4 +1,6 @@
-import { Logger, LogLevel, PikkuChannel } from '@pikku/core';
+import { Logger, LogLevel } from '@pikku/core';
+import { PikkuChannel } from '@pikku/core/channel';
+import { ErrorCode } from '@pikku/inspector';
 /**
  * Log message structure sent through the channel
  */
@@ -15,7 +17,7 @@ export declare class CLILoggerForwarder implements Logger {
     private logger;
     private channel;
     private level;
-    constructor(logger: Logger, channel: PikkuChannel<unknown, ForwardedLogMessage>);
+    constructor(logger: Logger, channel: PikkuChannel<unknown, any>);
     setLevel(level: LogLevel): void;
     private log;
     info(messageOrObj: string | Record<string, any>, ..._meta: any[]): void;
@@ -23,4 +25,6 @@ export declare class CLILoggerForwarder implements Logger {
     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

@@ -52,4 +52,13 @@ export class CLILoggerForwarder {
     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

@@ -1,7 +1,9 @@
 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;
@@ -14,6 +16,8 @@ export declare class CLILogger implements Logger {
     error(message: string): void;
     warn(message: string): void;
     debug(message: string): void;
+    critical(code: ErrorCode, message: string): void;
+    hasCriticalErrors(): boolean;
     private logPikkuLogo;
     private primary;
 }

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

@@ -8,9 +8,11 @@ const logo = `
 | |    | |  _ (|  _ (|  _ (| |_| |
 |_|    |_|_| _)_| _)____/
 `;
+const BASE_ERROR_URL = 'https://pikku.dev/errors';
 export class CLILogger {
     silent;
     level = LogLevel.info;
+    criticalErrors = [];
     constructor({ logLogo, silent = false, }) {
         this.silent = silent;
         if (logLogo && !silent) {
@@ -49,6 +51,15 @@ export class CLILogger {
             return;
         console.log(chalk.gray(message));
     }
+    critical(code, message) {
+        const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`;
+        const formattedMessage = `[${code}] ${message}\n  → ${url}`;
+        this.criticalErrors.push(formattedMessage);
+        console.error(chalk.red.bold(formattedMessage));
+    }
+    hasCriticalErrors() {
+        return this.criticalErrors.length > 0;
+    }
     logPikkuLogo() {
         this.primary(logo);
         // // When running from dist/, __filename is dist/src/services/cli-logger.service.js

package/dist/src/services.d.ts

@@ -6,6 +6,11 @@ import { ForwardedLogMessage } from './services/cli-logger-forwarder.service.js'
  * Default CLI renderer that logs output using the logger
  */
 export declare const defaultCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, SingletonServices, import("@pikku/core").CoreUserSession>;
+/**
+ * Client-safe CLI renderer that outputs to console (no service dependencies)
+ * This renderer can be used in CLI-over-channel clients
+ */
+export declare const clientCLIRenderer: import("@pikku/core").CorePikkuCLIRender<ForwardedLogMessage, import("@pikku/core").CoreServices, import("@pikku/core").CoreUserSession>;
 export declare const createConfig: CreateConfig<Config, [PikkuCLIConfig]>;
 /**
  * Singleton services factory for the Pikku CLI

package/dist/src/services.js

@@ -1,12 +1,65 @@
-import { pikkuCLIRender, } from '@pikku/core';
+import { pikkuCLIRender } from '@pikku/core/cli';
 import { LocalVariablesService } from '@pikku/core/services';
 import { CLILogger } from './services/cli-logger.service.js';
 import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
-import { inspect } from '@pikku/inspector';
+import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, } from '@pikku/inspector';
 import { glob } from 'tinyglobby';
 import path from 'path';
 import { CLILoggerForwarder, } from './services/cli-logger-forwarder.service.js';
+import { readFile, writeFile } from 'fs/promises';
 const logger = new CLILogger({ logLogo: true, silent: false });
+/**
+ * Parse a comma-separated string or array into an array of trimmed, non-empty strings
+ * Returns undefined if the input is empty/undefined or results in an empty array
+ */
+function parseCommaSeparated(value) {
+    if (!value)
+        return undefined;
+    // If already an array, flatten and split any comma-separated values
+    if (Array.isArray(value)) {
+        const flattened = value
+            .flatMap((item) => item.split(','))
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+        return flattened.length > 0 ? flattened : undefined;
+    }
+    // If string, split by comma
+    const parsed = value
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return parsed.length > 0 ? parsed : undefined;
+}
+/**
+ * Parse CLI filter arguments into InspectorFilters format
+ */
+function parseCLIFilters(data) {
+    const filters = {};
+    if (data.filters) {
+        return JSON.parse(data.filters);
+    }
+    // Parse each filter type from CLI arguments
+    const names = parseCommaSeparated(data.names);
+    const tags = parseCommaSeparated(data.tags);
+    const types = parseCommaSeparated(data.types);
+    const directories = parseCommaSeparated(data.directories);
+    const httpRoutes = parseCommaSeparated(data.httpRoutes);
+    const httpMethods = parseCommaSeparated(data.httpMethods);
+    // Only include non-undefined values in the result
+    if (names)
+        filters.names = names;
+    if (tags)
+        filters.tags = tags;
+    if (types)
+        filters.types = types;
+    if (directories)
+        filters.directories = directories;
+    if (httpRoutes)
+        filters.httpRoutes = httpRoutes;
+    if (httpMethods)
+        filters.httpMethods = httpMethods;
+    return filters;
+}
 /**
  * Default CLI renderer that logs output using the logger
  */
@@ -15,11 +68,39 @@ export const defaultCLIRenderer = pikkuCLIRender((_services, data) => {
         logger[data.level]({ message: data.message, type: data.type });
     }
 });
+/**
+ * Client-safe CLI renderer that outputs to console (no service dependencies)
+ * This renderer can be used in CLI-over-channel clients
+ */
+export const clientCLIRenderer = pikkuCLIRender((_services, data) => {
+    if (data) {
+        // Simple console output without service dependencies
+        const prefix = data.type ? `[${data.type}] ` : '';
+        console.log(`${prefix}${data.message}`);
+    }
+});
 export const createConfig = async (_variablesService, data) => {
-    const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], data, true);
+    const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true);
+    // Load inspector state from file if stateInput is provided
+    let preloadedInspectorState = undefined;
+    if (data.stateInput) {
+        try {
+            logger.info(`Loading inspector state from ${data.stateInput}`);
+            const stateJson = await readFile(data.stateInput, 'utf-8');
+            const serializedState = JSON.parse(stateJson);
+            preloadedInspectorState = deserializeInspectorState(serializedState);
+            logger.info(`Inspector state loaded successfully`);
+        }
+        catch (error) {
+            logger.error(`Failed to load inspector state from ${data.stateInput}: ${error.message}`);
+            throw error;
+        }
+    }
     return {
         ...cliConfig,
         ...data,
+        filters: parseCLIFilters(data),
+        preloadedInspectorState,
     };
 };
 /**
@@ -27,24 +108,41 @@ export const createConfig = async (_variablesService, data) => {
  * This function creates the singleton services used by the CLI and is created once on start.
  */
 export const createSingletonServices = async (config) => {
-    const { rootDir, srcDirectories, filters } = config;
+    const { rootDir, srcDirectories, filters, preloadedInspectorState, stateOutput, } = config;
     const variables = new LocalVariablesService();
-    let inspectorState = undefined;
+    // Store unfiltered state
+    let unfilteredState = preloadedInspectorState;
     const getInspectorState = async (refresh = false) => {
-        if (refresh || !inspectorState) {
+        // Get or refresh the unfiltered state
+        if (!unfilteredState || refresh) {
+            // Run inspector WITHOUT filters to get full state
             const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-            inspectorState = await inspect(logger, wiringFiles, {
-                filters,
+            unfilteredState = await inspect(logger, wiringFiles, {
+                // NO filters here - inspector returns full unfiltered state
                 types: {
                     configFileType: config.configFile,
-                    userSessionType: config.tags?.[0], // TODO: Properly handle type selection
-                    singletonServicesFactoryType: undefined,
-                    sessionServicesFactoryType: undefined,
+                    userSessionType: config.userSessionType,
+                    singletonServicesFactoryType: config.singletonServicesFactoryType,
+                    sessionServicesFactoryType: config.sessionServicesFactoryType,
                 },
             });
-            return inspectorState;
+            // Save unfiltered inspector state to file if stateOutput is provided
+            if (stateOutput && 'typesLookup' in unfilteredState) {
+                try {
+                    logger.info(`Saving inspector state to ${stateOutput}`);
+                    const serialized = serializeInspectorState(unfilteredState);
+                    await writeFile(stateOutput, JSON.stringify(serialized, null, 2), 'utf-8');
+                    logger.info(`Inspector state saved successfully`);
+                }
+                catch (error) {
+                    logger.error(`Failed to save inspector state to ${stateOutput}: ${error.message}`);
+                    // Don't throw - state saving is optional/nice-to-have
+                }
+            }
         }
-        return inspectorState;
+        // Apply filters as a post-processing step
+        const filteredState = filterInspectorState(unfilteredState, filters, logger);
+        return filteredState;
     };
     return {
         config,

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

@@ -4,8 +4,14 @@ export function generateCustomTypes(typesMap, requiredTypes) {
 // or are broken into simpler types
 ${Array.from(typesMap.customTypes.entries())
         .map(([name, { type, references }]) => {
-        references.forEach((name) => {
-            requiredTypes.add(name);
+        references.forEach((refName) => {
+            // Skip __object types (including those with suffixes like __object_abc123)
+            // These are placeholder types created by the inspector for invalid/broken functions
+            // (e.g., functions with type errors or missing return statements). Attempting to
+            // import these would fail since the source files don't actually export __object.
+            if (refName !== '__object' && !refName.startsWith('__object_')) {
+                requiredTypes.add(refName);
+            }
         });
         // Extract type names from the type string that might not be in references
         const typeString = type;

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

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