@pikku/cli 0.10.1 → 0.11.0

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

@@ -0,0 +1,60 @@
+/**
+ * Generate queue workers and RPC functions for workflow steps and orchestrator
+ */
+export const serializeWorkflowWorkers = (pathToPikkuTypes: string) => {
+  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/src/middleware/log-command-info-and-time.ts

@@ -15,21 +15,24 @@ 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 const logCommandInfoAndTime = ({
   commandStart,
   commandEnd,
 }: LogCommandInfoOptions): PikkuMiddleware => {
   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/src/services/cli-logger-forwarder.service.ts

@@ -78,7 +78,7 @@ export class CLILoggerForwarder implements Logger {
   }
 
   critical(code: ErrorCode, message: string) {
-    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/src/services/cli-logger.service.ts

@@ -11,11 +11,11 @@ const logo = `
 |_|    |_|_| _)_| _)____/
 `
 
-const BASE_ERROR_URL = 'https://pikku.dev/errors'
+const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors'
 
 export class CLILogger implements Logger {
   private silent: boolean
-  private level: LogLevel = LogLevel.info
+  private level: LogLevel = LogLevel.warn // default to warn level
   private criticalErrors: string[] = []
 
   constructor({
@@ -27,7 +27,7 @@ export class CLILogger implements Logger {
   }) {
     this.silent = silent
     if (logLogo && !silent) {
-      this.logPikkuLogo()
+      this.logLogo()
     }
   }
 
@@ -35,6 +35,14 @@ export class CLILogger implements Logger {
     this.level = level
   }
 
+  setSilent(silent: boolean): void {
+    this.silent = silent
+  }
+
+  isSilent(): boolean {
+    return this.silent
+  }
+
   info(message: string | { message: string; type?: string }) {
     if (this.level > LogLevel.info || this.silent) return
 
@@ -59,9 +67,16 @@ export class CLILogger implements Logger {
     console.error(chalk.yellow(message))
   }
 
-  debug(message: string) {
+  debug(message: string | { message: string; type?: string }) {
     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: ErrorCode, message: string) {
@@ -75,7 +90,7 @@ export class CLILogger implements Logger {
     return this.criticalErrors.length > 0
   }
 
-  private 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/src/services.ts

@@ -10,7 +10,7 @@ import {
   CreateSingletonServices,
 } from '@pikku/core'
 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 {
@@ -20,6 +20,7 @@ import {
   serializeInspectorState,
   deserializeInspectorState,
   filterInspectorState,
+  getInitialInspectorState,
 } from '@pikku/inspector'
 import { glob } from 'tinyglobby'
 import path from 'path'
@@ -30,7 +31,9 @@ import {
 } 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
@@ -94,7 +97,7 @@ function parseCLIFilters(data: any): InspectorFilters {
 export const defaultCLIRenderer = pikkuCLIRender<
   ForwardedLogMessage,
   SingletonServices
->((_services, data) => {
+>(({ logger }, data) => {
   if (data) {
     logger[data.level]({ message: data.message, type: data.type })
   }
@@ -105,11 +108,9 @@ export const defaultCLIRenderer = pikkuCLIRender<
  * This renderer can be used in CLI-over-channel clients
  */
 export const clientCLIRenderer = pikkuCLIRender<ForwardedLogMessage>(
-  (_services, data) => {
+  ({ 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 } as any)
     }
   }
 )
@@ -118,6 +119,37 @@ export const createConfig: CreateConfig<Config, [PikkuCLIConfig]> = async (
   _variablesService,
   data
 ) => {
+  // Determine log level based on CLI flags with precedence:
+  // --silent > --loglevel > --verbose > --info > default (warn)
+  let logLevel: LogLevel = LogLevel.warn // default
+  let isSilent = false
+
+  if ((data as any).silent) {
+    logLevel = LogLevel.critical
+    isSilent = true
+  } else if ((data as any).loglevel) {
+    const levelStr = (data as any).loglevel
+    if (LogLevel[levelStr] !== undefined) {
+      logLevel = LogLevel[levelStr as keyof typeof LogLevel]
+    } else {
+      logger.warn(
+        `Invalid log level "${levelStr}". Valid levels: trace, debug, info, warn, error, critical. Using default (warn).`
+      )
+    }
+  } else if ((data as any).verbose) {
+    logLevel = LogLevel.debug
+  } else if ((data as any).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
@@ -170,19 +202,62 @@ export const createSingletonServices: CreateSingletonServices<
     | Omit<InspectorState, 'typesLookup'>
     | undefined = preloadedInspectorState
 
-  const getInspectorState = async (refresh: boolean = false) => {
+  const getInspectorState = async (
+    refresh: boolean = false,
+    setupOnly: boolean = false,
+    bootstrapMode: boolean = 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`)
+            glob(`${path.join(rootDir, dir)}/**/*.ts`, {
+              ignore: config.ignoreFiles || [],
+            })
           )
         )
       ).flat()
-      unfilteredState = await inspect(logger, wiringFiles, {
-        // NO filters here - inspector returns full unfiltered state
+      unfilteredState = inspect(logger, wiringFiles, {
+        setupOnly,
         types: {
           configFileType: config.configFile,
           userSessionType: config.userSessionType,

package/src/utils/command-summary.ts

@@ -0,0 +1,103 @@
+import chalk from 'chalk'
+
+export interface CommandSummaryStats {
+  httpRoutes?: number
+  channels?: number
+  functions?: number
+  scheduledTasks?: number
+  queueWorkers?: number
+  mcpEndpoints?: number
+  cliCommands?: number
+  workflows?: number
+  [key: string]: number | undefined
+}
+
+/**
+ * Utility class to collect and display command execution summaries
+ */
+export class CommandSummary {
+  private stats: CommandSummaryStats = {}
+  private startTime: number
+  private commandName: string
+
+  constructor(commandName: string) {
+    this.commandName = commandName
+    this.startTime = Date.now()
+  }
+
+  /**
+   * Increment a stat counter
+   */
+  increment(key: keyof CommandSummaryStats, count: number = 1): void {
+    this.stats[key] = (this.stats[key] || 0) + count
+  }
+
+  /**
+   * Set a stat value directly
+   */
+  set(key: keyof CommandSummaryStats, value: number): void {
+    this.stats[key] = value
+  }
+
+  /**
+   * Get current stats
+   */
+  getStats(): CommandSummaryStats {
+    return { ...this.stats }
+  }
+
+  /**
+   * Get elapsed time in milliseconds
+   */
+  getElapsedTime(): number {
+    return Date.now() - this.startTime
+  }
+
+  /**
+   * Format the summary for display
+   */
+  format(): string {
+    const elapsed = this.getElapsedTime()
+    const lines: string[] = []
+
+    // Header with timing
+    lines.push(
+      chalk.green(`\npikku ${this.commandName} (completed in ${elapsed}ms)`)
+    )
+
+    // Stats
+    const statLabels: Record<keyof CommandSummaryStats, string> = {
+      httpRoutes: 'HTTP route',
+      channels: 'WebSocket channel',
+      functions: 'Function',
+      scheduledTasks: 'Scheduled task',
+      queueWorkers: 'Queue worker',
+      mcpEndpoints: 'MCP endpoint',
+      cliCommands: 'CLI command',
+      workflows: 'Workflow',
+    }
+
+    for (const [key, label] of Object.entries(statLabels)) {
+      const value = this.stats[key]
+      if (value !== undefined && value > 0) {
+        lines.push(chalk.gray(`  • ${value} ${label}${value > 1 ? 's' : ''}`))
+      }
+    }
+
+    // If no stats, show a simple completion message
+    if (Object.values(this.stats).every((v) => !v || v === 0)) {
+      return chalk.green(
+        `\npikku ${this.commandName} (completed in ${elapsed}ms)\n`
+      )
+    }
+
+    return lines.join('\n') + '\n'
+  }
+
+  /**
+   * Check if there are any stats to display
+   */
+  hasStats(): boolean {
+    return Object.values(this.stats).some((v) => v && v > 0)
+  }
+}

package/src/utils/file-writer.ts

@@ -51,7 +51,7 @@ export const writeFileInDir = async (
     await writeFile(path, content, 'utf-8')
 
     if (logWrite) {
-      logger.info({ message: `✓ File written to ${path}`, type: 'success' })
+      logger.debug({ message: `✓ File written to ${path}`, type: 'success' })
     }
   }
 }
@@ -66,7 +66,7 @@ export const removeFileInDir = async (
     await rm(path, { force: true })
 
     if (logRemove) {
-      logger.info({ message: `✓ File removed at ${path}`, type: 'success' })
+      logger.debug({ message: `✓ File removed at ${path}`, type: 'success' })
     }
   }
 }

package/src/utils/pikku-cli-config.ts

@@ -64,6 +64,19 @@ const _getPikkuCLIConfig = async (
           ...extendedConfig.packageMappings,
           ...config.packageMappings,
         },
+        ignoreFiles: config.ignoreFiles ??
+          extendedConfig.ignoreFiles ?? [
+            '**/*.test.ts',
+            '**/*.spec.ts',
+            '**/node_modules/**',
+            '**/dist/**',
+          ],
+        schema: {
+          additionalProperties: false,
+          supportsImportAttributes: false,
+          ...extendedConfig.schema,
+          ...config.schema,
+        },
       }
     } else {
       result = {
@@ -73,6 +86,17 @@ const _getPikkuCLIConfig = async (
         rootDir: config.rootDir
           ? resolve(configDir, config.rootDir)
           : configDir,
+        ignoreFiles: config.ignoreFiles ?? [
+          '**/*.test.ts',
+          '**/*.spec.ts',
+          '**/node_modules/**',
+          '**/dist/**',
+        ],
+        schema: {
+          additionalProperties: false,
+          supportsImportAttributes: false,
+          ...config.schema,
+        },
       }
     }
 
@@ -83,6 +107,7 @@ const _getPikkuCLIConfig = async (
     const rpcDir = join(result.outDir, 'rpc')
     const schedulerDir = join(result.outDir, 'scheduler')
     const queueDir = join(result.outDir, 'queue')
+    const workflowDir = join(result.outDir, 'workflow')
     const mcpDir = join(result.outDir, 'mcp')
     const cliDir = join(result.outDir, 'cli')
     const middlewareDir = join(result.outDir, 'middleware')
@@ -181,6 +206,17 @@ const _getPikkuCLIConfig = async (
       )
     }
 
+    // RPC config defaults
+    if (!result.rpc) {
+      result.rpc = {}
+    }
+    if (!result.rpc.remoteRpcWorkersPath) {
+      result.rpc.remoteRpcWorkersPath = join(
+        rpcDir,
+        'pikku-remote-rpc-workers.gen.ts'
+      )
+    }
+
     // Scheduler
     if (!result.schedulersWiringFile) {
       result.schedulersWiringFile = join(
@@ -224,6 +260,38 @@ const _getPikkuCLIConfig = async (
       result.queueTypesFile = join(queueDir, 'pikku-queue-types.gen.ts')
     }
 
+    // Workflows
+    if (!result.workflowsWiringFile) {
+      result.workflowsWiringFile = join(
+        workflowDir,
+        'pikku-workflow-wirings.gen.ts'
+      )
+    }
+    if (!result.workflowsWiringMetaFile) {
+      result.workflowsWiringMetaFile = join(
+        workflowDir,
+        'pikku-workflow-wirings-meta.gen.ts'
+      )
+    }
+    if (!result.workflowsWorkersFile) {
+      result.workflowsWorkersFile = join(
+        workflowDir,
+        'pikku-workflow-workers.gen.ts'
+      )
+    }
+    if (!result.workflowMapDeclarationFile) {
+      result.workflowMapDeclarationFile = join(
+        workflowDir,
+        'pikku-workflow-map.gen.d.ts'
+      )
+    }
+    if (!result.workflowTypesFile) {
+      result.workflowTypesFile = join(
+        workflowDir,
+        'pikku-workflow-types.gen.ts'
+      )
+    }
+
     // Services
     if (!result.servicesFile) {
       result.servicesFile = join(result.outDir, 'pikku-services.gen.ts')

package/src/utils/schema-generator.ts

@@ -12,15 +12,20 @@ export async function generateSchemas(
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
   httpWiringsMeta: HTTPWiringsMeta,
-  additionalTypes?: string[]
+  additionalTypes?: string[],
+  additionalProperties: boolean = false
 ): Promise<Record<string, JSONValue>> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
     const types = [...(inputs || []), ...(outputs || [])]
     for (const type of types) {
-      const uniqueName = typesMap.getUniqueName(type)
-      if (uniqueName) {
-        schemasSet.add(uniqueName)
+      try {
+        const uniqueName = typesMap.getUniqueName(type)
+        if (uniqueName) {
+          schemasSet.add(uniqueName)
+        }
+      } catch {
+        // Skip types not in typesMap (e.g., inline types in generated workflow workers)
       }
     }
   }
@@ -56,7 +61,7 @@ export async function generateSchemas(
     sortProps: true,
     strictTuples: false,
     encodeRefs: false,
-    additionalProperties: false,
+    additionalProperties,
   })
   const schemas: Record<string, JSONValue> = {}
 
@@ -86,8 +91,8 @@ export async function saveSchemas(
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  supportsImportAttributes: boolean,
-  additionalTypes?: string[]
+  additionalTypes?: string[],
+  supportsImportAttributes: boolean = false
 ) {
   await writeFileInDir(
     logger,
@@ -97,10 +102,24 @@ export async function saveSchemas(
 
   const desiredSchemas = new Set<string>([
     ...Object.values(functionsMeta)
-      .map(({ inputs, outputs }) => [
-        inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
-        outputs?.[0] ? typesMap.getUniqueName(outputs[0]) : undefined,
-      ])
+      .map(({ inputs, outputs }) => {
+        const types: (string | undefined)[] = []
+        if (inputs?.[0]) {
+          try {
+            types.push(typesMap.getUniqueName(inputs[0]))
+          } catch {
+            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
+          }
+        }
+        if (outputs?.[0]) {
+          try {
+            types.push(typesMap.getUniqueName(outputs[0]))
+          } catch {
+            // Skip types not in typesMap (e.g., inline types in generated workflow workers)
+          }
+        }
+        return types
+      })
       .flat()
       .filter(
         (s): s is string =>

package/types/application-types.d.ts

@@ -15,7 +15,11 @@ export interface Config extends CoreConfig<PikkuCLIConfig> {
 
 export interface SingletonServices extends CoreSingletonServices<Config> {
   logger: CLILogger
-  getInspectorState: (refresh?: boolean = false) => Promise<InspectorState>
+  getInspectorState: (
+    refresh?: boolean,
+    setupOnly?: boolean,
+    bootstrapMode?: boolean
+  ) => Promise<InspectorState>
 }
 
 export interface Services extends CoreServices<SingletonServices, {}> {}