@pikku/cli 0.10.1 → 0.11.0

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

@@ -27,11 +27,18 @@ export type RPCInvoke = <Name extends keyof RPCMap>(
   }
 ) => Promise<RPCMap[Name]['output']>
 
+// Import WorkflowMap for workflow typing
+import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+
 export type TypedPikkuRPC = {
   depth: number;
   global: boolean;
   invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any> 
+  invokeExposed: (name: string, data: any) => Promise<any>;
+  startWorkflow: <Name extends keyof WorkflowMap>(
+    name: Name,
+    input: WorkflowMap[Name]['input']
+  ) => Promise<{ runId: string }>;
 }
   `;
 };
@@ -47,8 +54,25 @@ function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
         const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
         const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         // Store the input and output types for RPCHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+        let inputType = 'null';
+        if (input) {
+            try {
+                inputType = typesMap.getTypeMeta(input).uniqueName;
+            }
+            catch {
+                inputType = 'any';
+            }
+        }
+        let outputType = 'null';
+        if (output) {
+            try {
+                outputType = typesMap.getTypeMeta(output).uniqueName;
+            }
+            catch {
+                outputType = 'any';
+            }
+        }
         requiredTypes.add(inputType);
         requiredTypes.add(outputType);
         // Add RPC entry

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

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

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

@@ -0,0 +1,12 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+export const pikkuWorkflowMap = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowMapDeclarationFile, packageMappings } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+    },
+});

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

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

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

@@ -0,0 +1,11 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const pikkuWorkflowTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { workflowTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+    },
+});

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

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

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

@@ -0,0 +1,55 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { ErrorCode } from '@pikku/inspector';
+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 { serializeWorkflowMeta } from './serialize-workflow-meta.js';
+import { serializeWorkflowTypes } from './serialize-workflow-types.js';
+import { serializeWorkflowMap } from './serialize-workflow-map.js';
+import { serializeWorkflowWorkers } from './serialize-workflow-workers.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { join } from 'path';
+export const pikkuWorkflow = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, } = config;
+        const { workflows, functions: functionState } = visitState;
+        const { typesMap } = functionState;
+        // Validate that workflowService service is configured if workflows are defined
+        const hasWorkflows = Object.keys(workflows.meta).length > 0;
+        if (hasWorkflows) {
+            const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
+            if (!hasWorkflowState) {
+                logger.critical(ErrorCode.WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED, 'Workflows detected but workflowService service not configured. Please add workflowService to your singleton services');
+                throw new Error('WorkflowState service not configured but workflows are defined');
+            }
+        }
+        // Write workflow metadata
+        await writeFileInDir(logger, workflowsWiringMetaFile, serializeWorkflowMeta(workflows.meta));
+        // Write workflow wirings (imports)
+        await writeFileInDir(logger, workflowsWiringFile, serializeFileImports('wireWorkflow', workflowsWiringFile, workflows.files, packageMappings));
+        // Write workflow types
+        const functionTypesImportPath = getFileImportRelativePath(workflowTypesFile, functionTypesFile, packageMappings);
+        await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath));
+        // Write workflow map (type-safe client API)
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta));
+        if (config.workflows) {
+            if (config.workflows.singleQueue) {
+                const workflowPath = join(config.rootDir, config.workflows.path);
+                const pathToPikkuTypes = getFileImportRelativePath(workflowPath, typesDeclarationFile, packageMappings);
+                await writeFileInDir(logger, workflowPath, serializeWorkflowWorkers(pathToPikkuTypes));
+            }
+            else if (workflows.files.size > 0) {
+                logger.critical(ErrorCode.WORKFLOW_MULTI_QUEUE_NOT_SUPPORTED, 'Multi-queue workflows are not supported when workflows.singleQueue is false. Please enable singleQueue in your configuration.');
+                return false;
+            }
+        }
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding Workflows',
+            commandEnd: 'Found Workflows',
+        }),
+    ],
+});

package/dist/src/functions/wirings/workflow/serialize-workflow-map.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowsMeta } from '@pikku/core/workflow';
+import { TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeWorkflowMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-map.js

@@ -0,0 +1,79 @@
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
+export const serializeWorkflowMap = (relativeToPath, packageMappings, typesMap, functionsMeta, workflowsMeta) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedWorkflows = generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for TypeScript to be aware of workflows and their input/output types
+ */
+
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface WorkflowHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedWorkflows}
+
+/**
+ * Type-safe workflow client API
+ */
+export type WorkflowClient<Name extends keyof WorkflowMap> = {
+  /**
+   * Start a new workflow run
+   */
+  start: (input: WorkflowMap[Name]['input']) => Promise<{ runId: string }>;
+
+  /**
+   * Get a workflow run by ID
+   */
+  getRun: <output extends keyof WorkflowMap[Name]>(runId: string) => Promise<WorkflowMap[Name][output]>;
+
+  /**
+   * Cancel a running workflow
+   */
+  cancelRun: (runId: string) => Promise<boolean>;
+}
+
+/**
+ * Map of all registered workflows with type-safe client APIs
+ */
+export type TypedWorkflowClients = {
+  [Name in keyof WorkflowMap]: WorkflowClient<Name>;
+}
+  `;
+};
+function generateWorkflows(workflowsMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect workflows
+    const workflowsObj = {};
+    // Iterate through workflow metadata
+    for (const [workflowName, { pikkuFuncName }] of Object.entries(workflowsMeta)) {
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${workflowName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Store the input and output types for WorkflowHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'void';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'void';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add workflow entry
+        workflowsObj[workflowName] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the Workflows object as a string
+    let workflowsStr = 'export type WorkflowMap = {\n';
+    for (const [workflowName, handler] of Object.entries(workflowsObj)) {
+        workflowsStr += `  readonly '${workflowName}': WorkflowHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+    }
+    workflowsStr += '};\n';
+    return workflowsStr;
+}

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowsMeta } from '@pikku/core/workflow';
+export declare const serializeWorkflowMeta: (workflowsMeta: WorkflowsMeta) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-meta.js

@@ -0,0 +1,10 @@
+export const serializeWorkflowMeta = (workflowsMeta) => {
+    const serializedOutput = [];
+    serializedOutput.push("import { pikkuState } from '@pikku/core'");
+    serializedOutput.push(`pikkuState('workflows', 'meta', ${JSON.stringify(workflowsMeta, null, 2)})`);
+    const workflowsMetaValues = Object.values(workflowsMeta);
+    if (workflowsMetaValues.length > 0) {
+        serializedOutput.push(`export type WorkflowNames = '${workflowsMetaValues.map((w) => w.workflowName).join("' | '")}'`);
+    }
+    return serializedOutput.join('\n');
+};

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

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

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

@@ -0,0 +1,95 @@
+/**
+ * Generates type definitions for workflow wirings
+ */
+export const serializeWorkflowTypes = (functionTypesImportPath) => {
+    return `/**
+ * Workflow-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreWorkflow, wireWorkflow as wireWorkflowCore, PikkuWorkflowInteraction, WorkflowStepOptions } from '@pikku/core/workflow'
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '@pikku/core'
+import type { PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { UserSession, SingletonServices } from '../../types/application-types.d.js'
+import type { TypedPikkuRPC, RPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
+
+/**
+ * Type definition for workflows that orchestrate multi-step processes.
+ * Workflows support both inline and remote execution modes with step caching.
+ */
+type WorkflowWiring = CoreWorkflow<
+  CorePikkuFunctionConfig<PikkuFunctionWorkflow<any, any>, PikkuPermission<any>, PikkuMiddleware>
+>
+
+/**
+ * Typed workflow interaction with RPC awareness
+ * Provides type-safe workflow.do() for RPC steps
+ */
+export interface TypedWorkflow extends PikkuWorkflowInteraction {
+  /**
+   * Execute a workflow step with RPC invocation (typed based on available RPCs)
+   * @template K - RPC name from the RPC map
+   */
+  do<K extends keyof RPCMap>(
+    stepName: string,
+    rpcName: K,
+    data: RPCMap[K]['input'],
+    options?: WorkflowStepOptions
+  ): Promise<RPCMap[K]['output']>
+
+  /**
+   * Execute a workflow step with inline function
+   * @template T - Return type of the inline function
+   */
+  do<T>(
+    stepName: string,
+    fn: () => T | Promise<T>,
+    options?: WorkflowStepOptions
+  ): Promise<T>
+}
+
+/**
+ * Workflow function type with typed workflow service
+ * Includes the workflow interaction object with typed RPC methods
+ */
+export type PikkuFunctionWorkflow<
+  In = unknown,
+  Out = never
+> = CorePikkuFunctionSessionless<
+  In,
+  Out,
+  null,
+  SingletonServices & {
+    rpc: TypedPikkuRPC
+    workflow: TypedWorkflow
+  },
+  UserSession
+>
+
+/**
+ * Creates a workflow function with typed input and output.
+ * Workflow functions have access to the workflow interaction object for step execution.
+ *
+ * @template In - Input type for the workflow
+ * @template Out - Output type for the workflow
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ */
+export const pikkuWorkflowFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionWorkflow<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionWorkflow<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Registers a workflow with the Pikku framework.
+ * Workflows can run in 'inline' (synchronous) or 'remote' (queue-based) execution modes.
+ *
+ * @param workflow - Workflow definition with name, execution mode, and handler function
+ */
+export const wireWorkflow = (workflow: WorkflowWiring) => {
+  wireWorkflowCore(workflow as any)
+}
+`;
+};

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export declare const serializeWorkflowWorkers: (pathToPikkuTypes: string) => string;

package/dist/src/functions/wirings/workflow/serialize-workflow-workers.js

@@ -0,0 +1,60 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export const serializeWorkflowWorkers = (pathToPikkuTypes) => {
+    return `/**
+ * Auto-generated workflow queue workers and RPC functions
+ * Do not edit manually - regenerate with 'npx pikku'
+ */
+import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
+
+/**
+ * Worker input types for generated queue workers
+ */
+export type WorkflowStepInput = {
+  runId: string
+  stepName: string
+  rpcName: string
+  data: any
+}
+
+export const pikkuWorkflowWorker = pikkuSessionlessFunc<
+  WorkflowStepInput,
+  void
+>({
+  func: async ({ workflowService, rpc }, { runId, stepName, rpcName, data }) => {
+    await workflowService!.executeWorkflowStep(runId, stepName, rpcName, data, rpc)
+  }
+})
+
+export const pikkuWorkflowOrchestrator = pikkuSessionlessFunc<
+  { runId: string },
+  void
+>({
+  func: async ({ workflowService, rpc }, { runId }) => {
+    await workflowService!.orchestrateWorkflow(runId, rpc)
+  }
+})
+
+export const pikkuWorkflowSleeper = pikkuSessionlessFunc<
+  { runId: string, stepId: string },
+  void
+>({
+  func: async ({ workflowService }, { runId, stepId }) => {
+    await workflowService!.executeWorkflowSleep(runId, stepId)
+  },
+  name: 'pikkuWorkflowStepSleeper',
+  internal: true,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-workflow-step-worker',
+  func: pikkuWorkflowWorker,
+})
+
+wireQueueWorker({
+  queueName: 'pikku-workflow-orchestrator',
+  func: pikkuWorkflowOrchestrator,
+})
+`;
+};

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

@@ -7,7 +7,7 @@ export interface LogCommandInfoOptions {
 }
 /**
  * Middleware to log command execution timing and status
- * Replaces the logCommandInfoAndTime wrapper function
+ * Uses debug level so it only shows with --verbose flag
  */
 export declare const logCommandInfoAndTime: ({ commandStart, commandEnd, }: LogCommandInfoOptions) => PikkuMiddleware;
 export {};

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

@@ -1,15 +1,18 @@
 /**
  * Middleware to log command execution timing and status
- * Replaces the logCommandInfoAndTime wrapper function
+ * Uses debug level so it only shows with --verbose flag
  */
 export const logCommandInfoAndTime = ({ commandStart, commandEnd, }) => {
     return async ({ logger }, _interaction, next) => {
-        // Log start
+        // Log start (debug level - only shows with --verbose)
         const start = Date.now();
-        logger.info(`• ${commandStart}...`);
+        logger.debug(`• ${commandStart}...`);
         // Execute the function
         await next();
-        // Log completion
-        logger.info(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
+        // Log completion (debug level - only shows with --verbose)
+        logger.debug({
+            type: 'success',
+            message: `✓ ${commandEnd} in ${Date.now() - start}ms.`,
+        });
     };
 };

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

@@ -53,7 +53,7 @@ export class CLILoggerForwarder {
         this.log('trace', LogLevel.trace, message);
     }
     critical(code, message) {
-        const url = `https://pikku.dev/docs/cli-errors/${code.toLowerCase()}`;
+        const url = `https://pikku.dev/docs/pikku-cli/errors/${code.toLowerCase()}`;
         const formattedMessage = `[${code}] ${message}\n  → ${url}`;
         this.error(formattedMessage);
     }

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

@@ -9,15 +9,20 @@ export declare class CLILogger implements Logger {
         silent?: boolean;
     });
     setLevel(level: LogLevel): void;
+    setSilent(silent: boolean): void;
+    isSilent(): boolean;
     info(message: string | {
         message: string;
         type?: string;
     }): void;
     error(message: string): void;
     warn(message: string): void;
-    debug(message: string): void;
+    debug(message: string | {
+        message: string;
+        type?: string;
+    }): void;
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;
-    private logPikkuLogo;
+    logLogo(): void;
     private primary;
 }

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

@@ -8,20 +8,26 @@ const logo = `
 | |    | |  _ (|  _ (|  _ (| |_| |
 |_|    |_|_| _)_| _)____/
 `;
-const BASE_ERROR_URL = 'https://pikku.dev/errors';
+const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors';
 export class CLILogger {
     silent;
-    level = LogLevel.info;
+    level = LogLevel.warn; // default to warn level
     criticalErrors = [];
     constructor({ logLogo, silent = false, }) {
         this.silent = silent;
         if (logLogo && !silent) {
-            this.logPikkuLogo();
+            this.logLogo();
         }
     }
     setLevel(level) {
         this.level = level;
     }
+    setSilent(silent) {
+        this.silent = silent;
+    }
+    isSilent() {
+        return this.silent;
+    }
     info(message) {
         if (this.level > LogLevel.info || this.silent)
             return;
@@ -49,7 +55,13 @@ export class CLILogger {
     debug(message) {
         if (this.level > LogLevel.debug || this.silent)
             return;
-        console.log(chalk.gray(message));
+        let c = chalk.gray;
+        if (typeof message === 'object') {
+            if (message.type === 'success') {
+                c = chalk.green;
+            }
+        }
+        console.log(c(typeof message === 'string' ? message : message.message));
     }
     critical(code, message) {
         const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`;
@@ -60,7 +72,7 @@ export class CLILogger {
     hasCriticalErrors() {
         return this.criticalErrors.length > 0;
     }
-    logPikkuLogo() {
+    logLogo() {
         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

package/dist/src/services.js

@@ -1,13 +1,15 @@
 import { pikkuCLIRender } from '@pikku/core/cli';
-import { LocalVariablesService } from '@pikku/core/services';
+import { LocalVariablesService, LogLevel } from '@pikku/core/services';
 import { CLILogger } from './services/cli-logger.service.js';
 import { getPikkuCLIConfig } from './utils/pikku-cli-config.js';
-import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, } from '@pikku/inspector';
+import { inspect, serializeInspectorState, deserializeInspectorState, filterInspectorState, getInitialInspectorState, } 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 });
+// Logger instance will be configured with log level from CLI flags in createConfig
+// Logo will be displayed conditionally in createConfig based on --silent flag
+const logger = new CLILogger({ logLogo: false, 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
@@ -63,7 +65,7 @@ function parseCLIFilters(data) {
 /**
  * Default CLI renderer that logs output using the logger
  */
-export const defaultCLIRenderer = pikkuCLIRender((_services, data) => {
+export const defaultCLIRenderer = pikkuCLIRender(({ logger }, data) => {
     if (data) {
         logger[data.level]({ message: data.message, type: data.type });
     }
@@ -72,14 +74,41 @@ export const defaultCLIRenderer = pikkuCLIRender((_services, data) => {
  * 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) => {
+export const clientCLIRenderer = pikkuCLIRender(({ logger }, data) => {
     if (data) {
-        // Simple console output without service dependencies
-        const prefix = data.type ? `[${data.type}] ` : '';
-        console.log(`${prefix}${data.message}`);
+        logger[data.level]?.({ message: data.message, type: data.type });
     }
 });
 export const createConfig = async (_variablesService, data) => {
+    // Determine log level based on CLI flags with precedence:
+    // --silent > --loglevel > --verbose > --info > default (warn)
+    let logLevel = LogLevel.warn; // default
+    let isSilent = false;
+    if (data.silent) {
+        logLevel = LogLevel.critical;
+        isSilent = true;
+    }
+    else if (data.loglevel) {
+        const levelStr = data.loglevel;
+        if (LogLevel[levelStr] !== undefined) {
+            logLevel = LogLevel[levelStr];
+        }
+        else {
+            logger.warn(`Invalid log level "${levelStr}". Valid levels: trace, debug, info, warn, error, critical. Using default (warn).`);
+        }
+    }
+    else if (data.verbose) {
+        logLevel = LogLevel.debug;
+    }
+    else if (data.info) {
+        logLevel = LogLevel.info;
+    }
+    logger.setLevel(logLevel);
+    logger.setSilent(isSilent);
+    // Display logo unless in silent mode
+    if (!isSilent) {
+        logger.logLogo();
+    }
     const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true);
     // Load inspector state from file if stateInput is provided
     let preloadedInspectorState = undefined;
@@ -112,13 +141,49 @@ export const createSingletonServices = async (config) => {
     const variables = new LocalVariablesService();
     // Store unfiltered state
     let unfilteredState = preloadedInspectorState;
-    const getInspectorState = async (refresh = false) => {
+    const getInspectorState = async (refresh = false, setupOnly = false, bootstrapMode = false) => {
+        // In bootstrap mode, return a minimal "zero state" with core types
+        // This allows bootstrap to run immediately without inspecting the codebase
+        if (bootstrapMode) {
+            const corePackagePath = '@pikku/core';
+            const initialState = getInitialInspectorState(rootDir);
+            // Populate filesAndMethods with core types from @pikku/core
+            initialState.filesAndMethods = {
+                userSessionType: {
+                    file: corePackagePath,
+                    variable: 'CoreUserSession',
+                    type: 'CoreUserSession',
+                    typePath: corePackagePath,
+                },
+                sessionServicesType: {
+                    file: corePackagePath,
+                    variable: 'CoreServices',
+                    type: 'CoreServices',
+                    typePath: corePackagePath,
+                },
+                singletonServicesType: {
+                    file: corePackagePath,
+                    variable: 'CoreSingletonServices',
+                    type: 'CoreSingletonServices',
+                    typePath: corePackagePath,
+                },
+                pikkuConfigType: {
+                    file: corePackagePath,
+                    variable: 'CoreConfig',
+                    type: 'CoreConfig',
+                    typePath: corePackagePath,
+                },
+            };
+            return initialState;
+        }
         // 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();
-            unfilteredState = await inspect(logger, wiringFiles, {
-                // NO filters here - inspector returns full unfiltered state
+            const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`, {
+                ignore: config.ignoreFiles || [],
+            })))).flat();
+            unfilteredState = inspect(logger, wiringFiles, {
+                setupOnly,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,